From 2d18c051098649bdc62a03a2ad81ec96d5ffff38 Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Tue, 23 Oct 2018 20:40:26 +0300 Subject: [PATCH 01/74] Implement project sceleton --- .gitignore | 104 +++++++++++++++++++++++++++++++++++ README.md | 30 ++++++++++ __init__.py | 20 +++++++ requirements.pip | 4 ++ tests/constants/constants.py | 27 +++++++++ tests/functional/__init__.py | 8 +++ tests/unit/__init__.py | 8 +++ 7 files changed, 201 insertions(+) create mode 100644 .gitignore create mode 100644 __init__.py create mode 100644 requirements.pip create mode 100644 tests/constants/constants.py create mode 100644 tests/functional/__init__.py create mode 100644 tests/unit/__init__.py diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..7db61e6 --- /dev/null +++ b/.gitignore @@ -0,0 +1,104 @@ +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ \ No newline at end of file diff --git a/README.md b/README.md index db61c2d..cd34619 100644 --- a/README.md +++ b/README.md @@ -1 +1,31 @@ # RestPyTAC +Short description + +# Setup +### Prerequisites +- Python [3.4 or higher](https://www.python.org/downloads/) +- Virtual environment [Virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/) +- Cloned repository [git](git@github.com:repo/repo.git) +- Docker [install](https://docs.docker.com/install/) +- Docker-compose [install](https://docs.docker.com/compose/install/) + +### Setting up the project +- create new virtual env `mkvirtualenv -p project_name`, +you could use any other name instead of `project_name` +- activate the env by running `workon project_name` +- Install modules `pip install -r ~//requirements.pip` +- Clone repository [rest_Spring_Docker](https://github.com/momel/rest_Spring_Docker) +- Up clone image: `cd ~/` and `docker-compose up -d` + +# Libs +- lib [unittest-for python 3.7.1](https://docs.python.org/3/library/unittest.html?highlight=unittest#module-unittest) +- lib [requests-2.20.0](http://docs.python-requests.org/en/master/) + +## Code quality +Project supports code style inspections with [pycodestyle]() tool. + +Run `pip install pycodestyle` to perform project code inspection using `pep8`. + +## Run tests +- To run unit tests execute `python unit.py`. +- To run functional tests execute `python functional.py`. \ No newline at end of file diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..65fb615 --- /dev/null +++ b/__init__.py @@ -0,0 +1,20 @@ +import unittest +import requests + +from tests.constants import constants + + +class ApiTestBase(unittest.TestCase): + + def test_pass(self): + self.assertTrue(True) + + def test_fail(self): + self.assertTrue(False) + + def test_error(self): + raise RuntimeError('Test error!') + + +if __name__ == '__main__': + unittest.main() diff --git a/requirements.pip b/requirements.pip new file mode 100644 index 0000000..5fc2c36 --- /dev/null +++ b/requirements.pip @@ -0,0 +1,4 @@ +pycodestyle +requests +nose +unittest \ No newline at end of file diff --git a/tests/constants/constants.py b/tests/constants/constants.py new file mode 100644 index 0000000..10df773 --- /dev/null +++ b/tests/constants/constants.py @@ -0,0 +1,27 @@ +# Default constants + + +class UserConstants: + + user = "admin" + password = "qwerty" + + +class DefaultToken: + + token = "0123456789ABCDEF0123456789ABCDEF" + + +class DefaultItem: + + item = "empty" + + +class DefaultNum: + + num = 1000 + + +class DefaultBool: + + bool = False diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py new file mode 100644 index 0000000..a6c87ee --- /dev/null +++ b/tests/functional/__init__.py @@ -0,0 +1,8 @@ +from __init__ import ApiTestBase + +from tests.constants import constants + + +class FunctionalTest(ApiTestBase): + + pass diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py new file mode 100644 index 0000000..62dfc02 --- /dev/null +++ b/tests/unit/__init__.py @@ -0,0 +1,8 @@ +from __init__ import ApiTestBase + +from tests.constants import constants + + +class UnitTest(ApiTestBase): + + pass From fe19451544eee035ceee3105fa9497389eb2befa Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Tue, 23 Oct 2018 21:51:13 +0300 Subject: [PATCH 02/74] Remove unittest from requirements.pip because error --- requirements.pip | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/requirements.pip b/requirements.pip index 5fc2c36..905ea49 100644 --- a/requirements.pip +++ b/requirements.pip @@ -1,4 +1,3 @@ pycodestyle requests -nose -unittest \ No newline at end of file +nose \ No newline at end of file From 5b29316afc4df5023ace46f19203e9ccc43f5988 Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Wed, 24 Oct 2018 18:45:06 +0300 Subject: [PATCH 03/74] add to constants InitUsers class fix imports in unit/__init__.py and functional/__init__.py move __init__.py from root to tests cleaned up file .gitignore fixed link, virtualenv instruction, docker instruction, running instruction and added new lib on git on file readme.md add version for modules in requirements.pip --- .gitignore | 46 +------------------------------- README.md | 16 +++++------ requirements.pip | 6 ++--- __init__.py => tests/__init__.py | 2 ++ tests/constants/constants.py | 13 +++++++++ tests/functional/__init__.py | 2 +- tests/unit/__init__.py | 2 +- 7 files changed, 29 insertions(+), 58 deletions(-) rename __init__.py => tests/__init__.py (92%) diff --git a/.gitignore b/.gitignore index 7db61e6..7fd7e89 100644 --- a/.gitignore +++ b/.gitignore @@ -3,9 +3,6 @@ __pycache__/ *.py[cod] *$py.class -# C extensions -*.so - # Distribution / packaging .Python build/ @@ -47,40 +44,12 @@ coverage.xml .hypothesis/ .pytest_cache/ -# Translations -*.mo -*.pot - -# Django stuff: -*.log -local_settings.py -db.sqlite3 - -# Flask stuff: -instance/ -.webassets-cache - -# Scrapy stuff: -.scrapy - -# Sphinx documentation -docs/_build/ - # PyBuilder target/ -# Jupyter Notebook -.ipynb_checkpoints - # pyenv .python-version -# celery beat schedule file -celerybeat-schedule - -# SageMath parsed files -*.sage.py - # Environments .env .venv @@ -88,17 +57,4 @@ env/ venv/ ENV/ env.bak/ -venv.bak/ - -# Spyder project settings -.spyderproject -.spyproject - -# Rope project settings -.ropeproject - -# mkdocs documentation -/site - -# mypy -.mypy_cache/ \ No newline at end of file +venv.bak/ \ No newline at end of file diff --git a/README.md b/README.md index cd34619..2310960 100644 --- a/README.md +++ b/README.md @@ -5,21 +5,21 @@ Short description ### Prerequisites - Python [3.4 or higher](https://www.python.org/downloads/) - Virtual environment [Virtualenvwrapper](https://virtualenvwrapper.readthedocs.io/en/latest/) -- Cloned repository [git](git@github.com:repo/repo.git) +- Cloned repository [git](https://github.com/Social-projects-Rivne/RestPyTAC) - Docker [install](https://docs.docker.com/install/) - Docker-compose [install](https://docs.docker.com/compose/install/) ### Setting up the project -- create new virtual env `mkvirtualenv -p project_name`, -you could use any other name instead of `project_name` -- activate the env by running `workon project_name` +- create new virtual env `mkvirtualenv api-tests -p ` +- activate the env by running `workon api-tests` - Install modules `pip install -r ~//requirements.pip` - Clone repository [rest_Spring_Docker](https://github.com/momel/rest_Spring_Docker) -- Up clone image: `cd ~/` and `docker-compose up -d` +- Run docker image from cloned repository: `cd ~/` and `docker-compose up -d` # Libs -- lib [unittest-for python 3.7.1](https://docs.python.org/3/library/unittest.html?highlight=unittest#module-unittest) +- lib [unittest-2.4.0](https://docs.python.org/3/library/unittest.html?highlight=unittest#module-unittest) - lib [requests-2.20.0](http://docs.python-requests.org/en/master/) +- lib [nose-1.3.7](https://nose.readthedocs.io/en/latest/index.html) ## Code quality Project supports code style inspections with [pycodestyle]() tool. @@ -27,5 +27,5 @@ Project supports code style inspections with [pycodestyle]() tool. Run `pip install pycodestyle` to perform project code inspection using `pep8`. ## Run tests -- To run unit tests execute `python unit.py`. -- To run functional tests execute `python functional.py`. \ No newline at end of file +- To run unit tests execute: `cd ~//tests/unit` and `nosetests __init__.py`. +- To run functional tests execute: `cd ~//tests/functional` and `nosetests __init__.py`. \ No newline at end of file diff --git a/requirements.pip b/requirements.pip index 905ea49..ff8e3db 100644 --- a/requirements.pip +++ b/requirements.pip @@ -1,3 +1,3 @@ -pycodestyle -requests -nose \ No newline at end of file +pycodestyle==2.4.0 +requests==2.20.0 +nose==1.3.7 \ No newline at end of file diff --git a/__init__.py b/tests/__init__.py similarity index 92% rename from __init__.py rename to tests/__init__.py index 65fb615..741b6e2 100644 --- a/__init__.py +++ b/tests/__init__.py @@ -1,5 +1,6 @@ import unittest import requests +import nose from tests.constants import constants @@ -18,3 +19,4 @@ def test_error(self): if __name__ == '__main__': unittest.main() + nose.main() diff --git a/tests/constants/constants.py b/tests/constants/constants.py index 10df773..ec5d6cd 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -25,3 +25,16 @@ class DefaultNum: class DefaultBool: bool = False + + +class InitUsers: + + users = {"admin": "qwerty", + "akimatc": "qwerty", + "khalaktc": "qwerty", + "kilinatc": "qwerty", + "OKonokhtc": "qwerty", + "otlumtc": "qwerty", + "slototc": "qwerty", + "vbudktc": "qwerty", + "vvasylystc": "qwerty"} \ No newline at end of file diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index a6c87ee..d42dc97 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -1,4 +1,4 @@ -from __init__ import ApiTestBase +from tests import ApiTestBase from tests.constants import constants diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py index 62dfc02..84fabc6 100644 --- a/tests/unit/__init__.py +++ b/tests/unit/__init__.py @@ -1,4 +1,4 @@ -from __init__ import ApiTestBase +from tests import ApiTestBase from tests.constants import constants From caf85b6056c9736a52e082c87316c2040249a8b0 Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Wed, 24 Oct 2018 18:48:40 +0300 Subject: [PATCH 04/74] removed non actually test strings --- tests/__init__.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/__init__.py b/tests/__init__.py index 741b6e2..847b59f 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -15,8 +15,3 @@ def test_fail(self): def test_error(self): raise RuntimeError('Test error!') - - -if __name__ == '__main__': - unittest.main() - nose.main() From 556333b9afb14329db1ea121c6a9c375cc5cf191 Mon Sep 17 00:00:00 2001 From: kotvitskiy123 Date: Thu, 25 Oct 2018 14:05:20 +0300 Subject: [PATCH 05/74] add new file to constants __init__.py changed name class UserConstants to DefaultUser and add new clases BaseUrl, Endpoints in file constants.py changed functionality in file functional/__init__.py added new file tests_login.py in functional added new python package utils with files __init__ and helper.py empty tests/__init__.py change nose run instruction --- README.md | 4 ++-- tests/__init__.py | 17 ----------------- tests/constants/__init__.py | 0 tests/constants/constants.py | 33 +++++++++++++++++++++++++++++++-- tests/functional/__init__.py | 14 ++++++++++---- tests/functional/tests_login.py | 11 +++++++++++ tests/unit/__init__.py | 8 -------- tests/utils/__init__.py | 0 tests/utils/helper.py | 5 +++++ 9 files changed, 59 insertions(+), 33 deletions(-) create mode 100644 tests/constants/__init__.py create mode 100644 tests/functional/tests_login.py create mode 100644 tests/utils/__init__.py create mode 100644 tests/utils/helper.py diff --git a/README.md b/README.md index 2310960..ce44c81 100644 --- a/README.md +++ b/README.md @@ -27,5 +27,5 @@ Project supports code style inspections with [pycodestyle]() tool. Run `pip install pycodestyle` to perform project code inspection using `pep8`. ## Run tests -- To run unit tests execute: `cd ~//tests/unit` and `nosetests __init__.py`. -- To run functional tests execute: `cd ~//tests/functional` and `nosetests __init__.py`. \ No newline at end of file +- To run unit tests execute: `cd ~//tests/unit` and run terminal command`nosetests -v`. +- To run functional tests execute: `cd ~//tests/functional` and run terminal command `nosetests -v`. \ No newline at end of file diff --git a/tests/__init__.py b/tests/__init__.py index 847b59f..e69de29 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,17 +0,0 @@ -import unittest -import requests -import nose - -from tests.constants import constants - - -class ApiTestBase(unittest.TestCase): - - def test_pass(self): - self.assertTrue(True) - - def test_fail(self): - self.assertTrue(False) - - def test_error(self): - raise RuntimeError('Test error!') diff --git a/tests/constants/__init__.py b/tests/constants/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/constants/constants.py b/tests/constants/constants.py index ec5d6cd..f7bea55 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -1,7 +1,7 @@ # Default constants -class UserConstants: +class DefaultUser: user = "admin" password = "qwerty" @@ -37,4 +37,33 @@ class InitUsers: "otlumtc": "qwerty", "slototc": "qwerty", "vbudktc": "qwerty", - "vvasylystc": "qwerty"} \ No newline at end of file + "vvasylystc": "qwerty"} + + +class BaseUrl: + + base_url = "http://localhost:8080" + + +class Endpoints: + + reset = "/reset" + login = "/login" + logout = "/logout" + user = "/user" + cooldowntime = "/cooldowntime" + tokenlifetime = "/tokenlifetime" + admins = "/admins" + login_admins = "/login/admins" + locked_admins ="/locked/admins" + users = "/users" + login_users = "/login/users" + login_tockens = "/login/tockens" + locked_users = "/locked/users" + locked_user= "/locked/user" + locked_reset = "/locked/reset" + item_user = "/item/user" + item = "/item" + items = "/items" + itemindexes ="/itemindexes" + diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index d42dc97..012cf0b 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -1,8 +1,14 @@ -from tests import ApiTestBase +import unittest +import requests -from tests.constants import constants +from tests.constants.constants import Endpoints +from tests.utils.helper import generate_full_url -class FunctionalTest(ApiTestBase): +class ApiTestBase(unittest.TestCase): - pass + def setUp(self): + self.request_session = requests.session() + + def login(self, name, password): + return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py new file mode 100644 index 0000000..f0c43ba --- /dev/null +++ b/tests/functional/tests_login.py @@ -0,0 +1,11 @@ +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers + +class Test(ApiTestBase): + + def test_login(self): + # sceleton, not refactoring + login = self.login("admin", "qwerty") + self.assertEquals(200, login.status_code) diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py index 84fabc6..e69de29 100644 --- a/tests/unit/__init__.py +++ b/tests/unit/__init__.py @@ -1,8 +0,0 @@ -from tests import ApiTestBase - -from tests.constants import constants - - -class UnitTest(ApiTestBase): - - pass diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/utils/helper.py b/tests/utils/helper.py new file mode 100644 index 0000000..59fe0e2 --- /dev/null +++ b/tests/utils/helper.py @@ -0,0 +1,5 @@ +from tests.constants.constants import BaseUrl + + +def generate_full_url(path): + return "{}{}".format(BaseUrl.base_url, path) \ No newline at end of file From eb96ee0032b0bdd9e3f0b1daacd652d4a940a285 Mon Sep 17 00:00:00 2001 From: asstelite Date: Fri, 26 Oct 2018 13:05:37 +0300 Subject: [PATCH 06/74] saving work progress --- tests/functional/__init__.py | 5 +++-- tests/functional/tests_locked.py | 24 ++++++++++++++++++++++++ 2 files changed, 27 insertions(+), 2 deletions(-) create mode 100644 tests/functional/tests_locked.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 012cf0b..000e14a 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -7,8 +7,9 @@ class ApiTestBase(unittest.TestCase): - def setUp(self): - self.request_session = requests.session() + @classmethod + def setUpClass(cls): + cls.request_session = requests.session() def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py new file mode 100644 index 0000000..feeeb85 --- /dev/null +++ b/tests/functional/tests_locked.py @@ -0,0 +1,24 @@ +import unittest +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import Endpoints, DefaultUser +from tests.utils.helper import generate_full_url + +class TestLocked(ApiTestBase): + + @classmethod + def setUpClass(cls): + """Return admin token""" + response = cls.login(DefaultUser.user, DefaultUser.password) + cls.adminToken = response.json()['content'] + + + + + def test_locked(self): + """Test functionality of locking users""" + + + + From 0c26dfca318e17434392d05aa72001dbc2f92c9b Mon Sep 17 00:00:00 2001 From: asstelite Date: Fri, 26 Oct 2018 13:43:20 +0300 Subject: [PATCH 07/74] returned to previous stage --- tests/functional/__init__.py | 6 +++--- tests/functional/tests_locked.py | 14 ++++++++++---- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 000e14a..8cd0d97 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -7,9 +7,9 @@ class ApiTestBase(unittest.TestCase): - @classmethod - def setUpClass(cls): - cls.request_session = requests.session() + + def setUp(self): + self.request_session = requests.session() def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index feeeb85..c62f65b 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -7,17 +7,23 @@ class TestLocked(ApiTestBase): - @classmethod - def setUpClass(cls): + + def setUp(self): """Return admin token""" - response = cls.login(DefaultUser.user, DefaultUser.password) - cls.adminToken = response.json()['content'] + super().setUp() + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] def test_locked(self): """Test functionality of locking users""" + + + def test_not_locked(self): + """User should not be locked""" + From 2feac883e4779715ccb52eee2ead9afae891d3cd Mon Sep 17 00:00:00 2001 From: abertash Date: Fri, 26 Oct 2018 14:32:27 +0300 Subject: [PATCH 08/74] Add new file for test cool down time changes. Add new function at init file for test cool down time changes. --- tests/functional/__init__.py | 4 ++++ tests/functional/tests_cooldowntime.py | 26 ++++++++++++++++++++++++++ 2 files changed, 30 insertions(+) create mode 100644 tests/functional/tests_cooldowntime.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 012cf0b..c8a92b2 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -12,3 +12,7 @@ def setUp(self): def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) + + def change_cool_down_time(self, token, new_value): + return self.request_session.put(generate_full_url(Endpoints.cooldowntime), + params={"token": token, "time": new_value}) \ No newline at end of file diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py new file mode 100644 index 0000000..5e87ba9 --- /dev/null +++ b/tests/functional/tests_cooldowntime.py @@ -0,0 +1,26 @@ +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, DefaultUser, Endpoints +from tests.utils.helper import generate_full_url + + +class Test(ApiTestBase): + + def test_set_cool_down_time(self): + """ + Change the cool down time by admin + :return: + """ + new_CDT = 500000 + + login = self.login(DefaultUser.user, DefaultUser.password) + token = login.json()["content"] + + # kwargs = {"token": token, "time": new_CDT} + req = self.change_cool_down_time(token, new_CDT) + + last_req = requests.get(generate_full_url(Endpoints.cooldowntime)) + CDT_after = last_req.json()["content"] + + self.assertEqual(CDT_after, new_CDT) \ No newline at end of file From a3518d44c70e8dd6f7412148090d9d917937e95d Mon Sep 17 00:00:00 2001 From: asstelite Date: Fri, 26 Oct 2018 14:35:13 +0300 Subject: [PATCH 09/74] just saving work --- tests/functional/__init__.py | 3 ++- tests/functional/tests_locked.py | 9 ++++++++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 8cd0d97..5bfba9f 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -1,6 +1,7 @@ import unittest import requests +from urllib3 import response from tests.constants.constants import Endpoints from tests.utils.helper import generate_full_url @@ -11,5 +12,5 @@ class ApiTestBase(unittest.TestCase): def setUp(self): self.request_session = requests.session() - def login(self, name, password): + def login(self, name:str, password:str) -> response: return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index c62f65b..b64b8c3 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -19,7 +19,14 @@ def setUp(self): def test_locked(self): """Test functionality of locking users""" - + passwords = ['voron','password', 'birthday', 'petname'] + for password in passwords: + self.login('khalaktc', password ) + kwargs = {'token': self.adminToken, } + locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users = locked_users_request.json()['content'] + print(locked_users) + self.assertEqual('0', '0') def test_not_locked(self): """User should not be locked""" From fc05e0556128a105f9214e280383a899b4958028 Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Thu, 25 Oct 2018 14:05:20 +0300 Subject: [PATCH 10/74] add class InitInvalidUsers to constants.py remove tests_login.py to the new branch pycodestyle fix in helper.py add configuration file .pylintrc ad pylint in requirements.pip --- .pylintrc | 558 +++++++++++++++++++++++++++++++++++ README.md | 4 +- requirements.pip | 3 +- tests/__init__.py | 17 -- tests/constants/__init__.py | 0 tests/constants/constants.py | 46 ++- tests/functional/__init__.py | 14 +- tests/unit/__init__.py | 8 - tests/utils/__init__.py | 0 tests/utils/helper.py | 5 + 10 files changed, 621 insertions(+), 34 deletions(-) create mode 100644 .pylintrc create mode 100644 tests/constants/__init__.py create mode 100644 tests/utils/__init__.py create mode 100644 tests/utils/helper.py diff --git a/.pylintrc b/.pylintrc new file mode 100644 index 0000000..a54992f --- /dev/null +++ b/.pylintrc @@ -0,0 +1,558 @@ +[MASTER] + +# A comma-separated list of package or module names from where C extensions may +# be loaded. Extensions are loading into the active Python interpreter and may +# run arbitrary code. +extension-pkg-whitelist= + +# Add files or directories to the blacklist. They should be base names, not +# paths. +ignore=CVS + +# Add files or directories matching the regex patterns to the blacklist. The +# regex matches against base names, not paths. +ignore-patterns= + +# Python code to execute, usually for sys.path manipulation such as +# pygtk.require(). +#init-hook= + +# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the +# number of processors available to use. +jobs=1 + +# Control the amount of potential inferred values when inferring a single +# object. This can help the performance when dealing with large functions or +# complex, nested conditions. +limit-inference-results=100 + +# List of plugins (as comma separated values of python modules names) to load, +# usually to register additional checkers. +load-plugins= + +# Pickle collected data for later comparisons. +persistent=yes + +# Specify a configuration file. +#rcfile= + +# When enabled, pylint would attempt to guess common misconfiguration and emit +# user-friendly hints instead of false-positive error messages. +suggestion-mode=yes + +# Allow loading of arbitrary C extensions. Extensions are imported into the +# active Python interpreter and may run arbitrary code. +unsafe-load-any-extension=no + + +[MESSAGES CONTROL] + +# Only show warnings with the listed confidence levels. Leave empty to show +# all. Valid levels: HIGH, INFERENCE, INFERENCE_FAILURE, UNDEFINED. +confidence= + +# Disable the message, report, category or checker with the given id(s). You +# can either give multiple identifiers separated by comma (,) or put this +# option multiple times (only on the command line, not in the configuration +# file where it should appear only once). You can also use "--disable=all" to +# disable everything first and then reenable specific checks. For example, if +# you want to run only the similarities checker, you can use "--disable=all +# --enable=similarities". If you want to run only the classes checker, but have +# no Warning level messages displayed, use "--disable=all --enable=classes +# --disable=W". +disable=print-statement, + parameter-unpacking, + unpacking-in-except, + old-raise-syntax, + backtick, + long-suffix, + old-ne-operator, + old-octal-literal, + import-star-module-level, + non-ascii-bytes-literal, + raw-checker-failed, + bad-inline-option, + locally-disabled, + locally-enabled, + file-ignored, + suppressed-message, + useless-suppression, + deprecated-pragma, + use-symbolic-message-instead, + apply-builtin, + basestring-builtin, + buffer-builtin, + cmp-builtin, + coerce-builtin, + execfile-builtin, + file-builtin, + long-builtin, + raw_input-builtin, + reduce-builtin, + standarderror-builtin, + unicode-builtin, + xrange-builtin, + coerce-method, + delslice-method, + getslice-method, + setslice-method, + no-absolute-import, + old-division, + dict-iter-method, + dict-view-method, + next-method-called, + metaclass-assignment, + indexing-exception, + raising-string, + reload-builtin, + oct-method, + hex-method, + nonzero-method, + cmp-method, + input-builtin, + round-builtin, + intern-builtin, + unichr-builtin, + map-builtin-not-iterating, + zip-builtin-not-iterating, + range-builtin-not-iterating, + filter-builtin-not-iterating, + using-cmp-argument, + eq-without-hash, + div-method, + idiv-method, + rdiv-method, + exception-message-attribute, + invalid-str-codec, + sys-max-int, + bad-python3-import, + deprecated-string-function, + deprecated-str-translate-call, + deprecated-itertools-function, + deprecated-types-field, + next-method-defined, + dict-items-not-iterating, + dict-keys-not-iterating, + dict-values-not-iterating, + deprecated-operator-function, + deprecated-urllib-function, + xreadlines-attribute, + deprecated-sys-function, + exception-escape, + comprehension-escape + +# Enable the message, report, category or checker with the given id(s). You can +# either give multiple identifier separated by comma (,) or put this option +# multiple time (only on the command line, not in the configuration file where +# it should appear only once). See also the "--disable" option for examples. +enable=c-extension-no-member + + +[REPORTS] + +# Python expression which should return a note less than 10 (10 is the highest +# note). You have access to the variables errors warning, statement which +# respectively contain the number of errors / warnings messages and the total +# number of statements analyzed. This is used by the global evaluation report +# (RP0004). +evaluation=10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10) + +# Template used to display messages. This is a python new-style format string +# used to format the message information. See doc for all details. +#msg-template= + +# Set the output format. Available formats are text, parseable, colorized, json +# and msvs (visual studio). You can also give a reporter class, e.g. +# mypackage.mymodule.MyReporterClass. +output-format=text + +# Tells whether to display a full report or only the messages. +reports=no + +# Activate the evaluation score. +score=yes + + +[REFACTORING] + +# Maximum number of nested blocks for function / method body +max-nested-blocks=5 + +# Complete name of functions that never returns. When checking for +# inconsistent-return-statements if a never returning function is called then +# it will be considered as an explicit return statement and no message will be +# printed. +never-returning-functions=sys.exit + + +[MISCELLANEOUS] + +# List of note tags to take in consideration, separated by a comma. +notes=FIXME, + XXX, + TODO + + +[FORMAT] + +# Expected format of line ending, e.g. empty (any line ending), LF or CRLF. +expected-line-ending-format= + +# Regexp for a line that is allowed to be longer than the limit. +ignore-long-lines=^\s*(# )??$ + +# Number of spaces of indent required inside a hanging or continued line. +indent-after-paren=4 + +# String used as indentation unit. This is usually " " (4 spaces) or "\t" (1 +# tab). +indent-string=' ' + +# Maximum number of characters on a single line. +max-line-length=120 + +# Maximum number of lines in a module. +max-module-lines=1000 + +# List of optional constructs for which whitespace checking is disabled. `dict- +# separator` is used to allow tabulation in dicts, etc.: {1 : 1,\n222: 2}. +# `trailing-comma` allows a space between comma and closing bracket: (a, ). +# `empty-line` allows space-only lines. +no-space-check=trailing-comma, + dict-separator + +# Allow the body of a class to be on the same line as the declaration if body +# contains single statement. +single-line-class-stmt=no + +# Allow the body of an if to be on the same line as the test if there is no +# else. +single-line-if-stmt=no + + +[VARIABLES] + +# List of additional names supposed to be defined in builtins. Remember that +# you should avoid to define new builtins when possible. +additional-builtins= + +# Tells whether unused global variables should be treated as a violation. +allow-global-unused-variables=yes + +# List of strings which can identify a callback function by name. A callback +# name must start or end with one of those strings. +callbacks=cb_, + _cb + +# A regular expression matching the name of dummy variables (i.e. expected to +# not be used). +dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_ + +# Argument names that match this expression will be ignored. Default to name +# with leading underscore. +ignored-argument-names=_.*|^ignored_|^unused_ + +# Tells whether we should check for unused import in __init__ files. +init-import=no + +# List of qualified module names which can have objects that can redefine +# builtins. +redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io + + +[SIMILARITIES] + +# Ignore comments when computing similarities. +ignore-comments=yes + +# Ignore docstrings when computing similarities. +ignore-docstrings=yes + +# Ignore imports when computing similarities. +ignore-imports=no + +# Minimum lines number of a similarity. +min-similarity-lines=4 + + +[TYPECHECK] + +# List of decorators that produce context managers, such as +# contextlib.contextmanager. Add to this list to register other decorators that +# produce valid context managers. +contextmanager-decorators=contextlib.contextmanager + +# List of members which are set dynamically and missed by pylint inference +# system, and so shouldn't trigger E1101 when accessed. Python regular +# expressions are accepted. +generated-members= + +# Tells whether missing members accessed in mixin class should be ignored. A +# mixin class is detected if its name ends with "mixin" (case insensitive). +ignore-mixin-members=yes + +# Tells whether to warn about missing members when the owner of the attribute +# is inferred to be None. +ignore-none=yes + +# This flag controls whether pylint should warn about no-member and similar +# checks whenever an opaque object is returned when inferring. The inference +# can return multiple potential results while evaluating a Python object, but +# some branches might not be evaluated, which results in partial inference. In +# that case, it might be useful to still emit no-member and other checks for +# the rest of the inferred objects. +ignore-on-opaque-inference=yes + +# List of class names for which member attributes should not be checked (useful +# for classes with dynamically set attributes). This supports the use of +# qualified names. +ignored-classes=optparse.Values,thread._local,_thread._local + +# List of module names for which member attributes should not be checked +# (useful for modules/projects where namespaces are manipulated during runtime +# and thus existing member attributes cannot be deduced by static analysis. It +# supports qualified module names, as well as Unix pattern matching. +ignored-modules= + +# Show a hint with possible names when a member name was not found. The aspect +# of finding the hint is based on edit distance. +missing-member-hint=yes + +# The minimum edit distance a name should have in order to be considered a +# similar match for a missing member name. +missing-member-hint-distance=1 + +# The total number of similar names that should be taken in consideration when +# showing a hint for a missing member. +missing-member-max-choices=1 + + +[BASIC] + +# Naming style matching correct argument names. +argument-naming-style=snake_case + +# Regular expression matching correct argument names. Overrides argument- +# naming-style. +#argument-rgx= + +# Naming style matching correct attribute names. +attr-naming-style=snake_case + +# Regular expression matching correct attribute names. Overrides attr-naming- +# style. +#attr-rgx= + +# Bad variable names which should always be refused, separated by a comma. +bad-names=foo, + bar, + baz, + toto, + tutu, + tata + +# Naming style matching correct class attribute names. +class-attribute-naming-style=any + +# Regular expression matching correct class attribute names. Overrides class- +# attribute-naming-style. +#class-attribute-rgx= + +# Naming style matching correct class names. +class-naming-style=PascalCase + +# Regular expression matching correct class names. Overrides class-naming- +# style. +#class-rgx= + +# Naming style matching correct constant names. +const-naming-style=UPPER_CASE + +# Regular expression matching correct constant names. Overrides const-naming- +# style. +#const-rgx= + +# Minimum line length for functions/classes that require docstrings, shorter +# ones are exempt. +docstring-min-length=-1 + +# Naming style matching correct function names. +function-naming-style=snake_case + +# Regular expression matching correct function names. Overrides function- +# naming-style. +#function-rgx= + +# Good variable names which should always be accepted, separated by a comma. +good-names=i, + j, + k, + ex, + Run, + _ + +# Include a hint for the correct naming format with invalid-name. +include-naming-hint=no + +# Naming style matching correct inline iteration names. +inlinevar-naming-style=any + +# Regular expression matching correct inline iteration names. Overrides +# inlinevar-naming-style. +#inlinevar-rgx= + +# Naming style matching correct method names. +method-naming-style=snake_case + +# Regular expression matching correct method names. Overrides method-naming- +# style. +#method-rgx= + +# Naming style matching correct module names. +module-naming-style=snake_case + +# Regular expression matching correct module names. Overrides module-naming- +# style. +#module-rgx= + +# Colon-delimited sets of names that determine each other's naming style when +# the name regexes allow several styles. +name-group= + +# Regular expression which should only match function or class names that do +# not require a docstring. +no-docstring-rgx=^_ + +# List of decorators that produce properties, such as abc.abstractproperty. Add +# to this list to register other decorators that produce valid properties. +# These decorators are taken in consideration only for invalid-name. +property-classes=abc.abstractproperty + +# Naming style matching correct variable names. +variable-naming-style=snake_case + +# Regular expression matching correct variable names. Overrides variable- +# naming-style. +#variable-rgx= + + +[SPELLING] + +# Limits count of emitted suggestions for spelling mistakes. +max-spelling-suggestions=4 + +# Spelling dictionary name. Available dictionaries: none. To make it working +# install python-enchant package.. +spelling-dict= + +# List of comma separated words that should not be checked. +spelling-ignore-words= + +# A path to a file that contains private dictionary; one word per line. +spelling-private-dict-file= + +# Tells whether to store unknown words to indicated private dictionary in +# --spelling-private-dict-file option instead of raising a message. +spelling-store-unknown-words=no + + +[LOGGING] + +# Logging modules to check that the string format arguments are in logging +# function parameter format. +logging-modules=logging + + +[IMPORTS] + +# Allow wildcard imports from modules that define __all__. +allow-wildcard-with-all=no + +# Analyse import fallback blocks. This can be used to support both Python 2 and +# 3 compatible code, which means that the block might have code that exists +# only in one or another interpreter, leading to false positives when analysed. +analyse-fallback-blocks=no + +# Deprecated modules which should not be used, separated by a comma. +deprecated-modules=optparse,tkinter.tix + +# Create a graph of external dependencies in the given file (report RP0402 must +# not be disabled). +ext-import-graph= + +# Create a graph of every (i.e. internal and external) dependencies in the +# given file (report RP0402 must not be disabled). +import-graph= + +# Create a graph of internal dependencies in the given file (report RP0402 must +# not be disabled). +int-import-graph= + +# Force import order to recognize a module as part of the standard +# compatibility libraries. +known-standard-library= + +# Force import order to recognize a module as part of a third party library. +known-third-party=enchant + + +[DESIGN] + +# Maximum number of arguments for function / method. +max-args=5 + +# Maximum number of attributes for a class (see R0902). +max-attributes=7 + +# Maximum number of boolean expressions in an if statement. +max-bool-expr=5 + +# Maximum number of branch for function / method body. +max-branches=12 + +# Maximum number of locals for function / method body. +max-locals=15 + +# Maximum number of parents for a class (see R0901). +max-parents=7 + +# Maximum number of public methods for a class (see R0904). +max-public-methods=20 + +# Maximum number of return / yield for function / method body. +max-returns=6 + +# Maximum number of statements in function / method body. +max-statements=50 + +# Minimum number of public methods for a class (see R0903). +min-public-methods=2 + + +[CLASSES] + +# List of method names used to declare (i.e. assign) instance attributes. +defining-attr-methods=__init__, + __new__, + setUp + +# List of member names, which should be excluded from the protected access +# warning. +exclude-protected=_asdict, + _fields, + _replace, + _source, + _make + +# List of valid names for the first argument in a class method. +valid-classmethod-first-arg=cls + +# List of valid names for the first argument in a metaclass class method. +valid-metaclass-classmethod-first-arg=cls + + +[EXCEPTIONS] + +# Exceptions that will emit a warning when being caught. Defaults to +# "Exception". +overgeneral-exceptions=Exception diff --git a/README.md b/README.md index 2310960..ce44c81 100644 --- a/README.md +++ b/README.md @@ -27,5 +27,5 @@ Project supports code style inspections with [pycodestyle]() tool. Run `pip install pycodestyle` to perform project code inspection using `pep8`. ## Run tests -- To run unit tests execute: `cd ~//tests/unit` and `nosetests __init__.py`. -- To run functional tests execute: `cd ~//tests/functional` and `nosetests __init__.py`. \ No newline at end of file +- To run unit tests execute: `cd ~//tests/unit` and run terminal command`nosetests -v`. +- To run functional tests execute: `cd ~//tests/functional` and run terminal command `nosetests -v`. \ No newline at end of file diff --git a/requirements.pip b/requirements.pip index ff8e3db..d0829e3 100644 --- a/requirements.pip +++ b/requirements.pip @@ -1,3 +1,4 @@ pycodestyle==2.4.0 requests==2.20.0 -nose==1.3.7 \ No newline at end of file +nose==1.3.7 +pylint==2.1.1 \ No newline at end of file diff --git a/tests/__init__.py b/tests/__init__.py index 847b59f..e69de29 100644 --- a/tests/__init__.py +++ b/tests/__init__.py @@ -1,17 +0,0 @@ -import unittest -import requests -import nose - -from tests.constants import constants - - -class ApiTestBase(unittest.TestCase): - - def test_pass(self): - self.assertTrue(True) - - def test_fail(self): - self.assertTrue(False) - - def test_error(self): - raise RuntimeError('Test error!') diff --git a/tests/constants/__init__.py b/tests/constants/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/constants/constants.py b/tests/constants/constants.py index ec5d6cd..d224317 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -1,7 +1,7 @@ # Default constants -class UserConstants: +class DefaultUser: user = "admin" password = "qwerty" @@ -37,4 +37,46 @@ class InitUsers: "otlumtc": "qwerty", "slototc": "qwerty", "vbudktc": "qwerty", - "vvasylystc": "qwerty"} \ No newline at end of file + "vvasylystc": "qwerty"} + + +class InitInvalidUsers: + + invalid_users = {"admin": "QWERTY", + "akimatc1": "qwerty", + "khalaktc": "", + "": "qwerty", + "OKonokhtc": "OKonokhtc"} + + +class BaseUrl: + + base_url = "http://localhost:8080" + + +class InvalidUrl: + + invalid_url = "http://localhost:80801" + + +class Endpoints: + + reset = "/reset" + login = "/login" + logout = "/logout" + user = "/user" + cooldowntime = "/cooldowntime" + tokenlifetime = "/tokenlifetime" + admins = "/admins" + login_admins = "/login/admins" + locked_admins = "/locked/admins" + users = "/users" + login_users = "/login/users" + login_tockens = "/login/tockens" + locked_users = "/locked/users" + locked_user = "/locked/user" + locked_reset = "/locked/reset" + item_user = "/item/user" + item = "/item" + items = "/items" + itemindexes = "/itemindexes" diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index d42dc97..012cf0b 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -1,8 +1,14 @@ -from tests import ApiTestBase +import unittest +import requests -from tests.constants import constants +from tests.constants.constants import Endpoints +from tests.utils.helper import generate_full_url -class FunctionalTest(ApiTestBase): +class ApiTestBase(unittest.TestCase): - pass + def setUp(self): + self.request_session = requests.session() + + def login(self, name, password): + return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) diff --git a/tests/unit/__init__.py b/tests/unit/__init__.py index 84fabc6..e69de29 100644 --- a/tests/unit/__init__.py +++ b/tests/unit/__init__.py @@ -1,8 +0,0 @@ -from tests import ApiTestBase - -from tests.constants import constants - - -class UnitTest(ApiTestBase): - - pass diff --git a/tests/utils/__init__.py b/tests/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/utils/helper.py b/tests/utils/helper.py new file mode 100644 index 0000000..f75f75e --- /dev/null +++ b/tests/utils/helper.py @@ -0,0 +1,5 @@ +from tests.constants.constants import BaseUrl + + +def generate_full_url(path): + return "{}{}".format(BaseUrl.base_url, path) From d81d26900b4952ccd03046267a80b9a7b794f0e8 Mon Sep 17 00:00:00 2001 From: abertash Date: Sat, 27 Oct 2018 03:25:38 +0300 Subject: [PATCH 11/74] My propose for changes at constans.py: in the class "DefaultUser" I separate user and admin. In my tests I need login like user and like admin, and I think that it is best way. ATTENTION! You will need refactor your code, because now DefaultUser.user != admin. Add new function to get current cool down time. End write tests for /cooldowntime --- tests/constants/constants.py | 4 ++- tests/functional/__init__.py | 5 ++- tests/functional/tests_cooldowntime.py | 47 +++++++++++++++++++++++--- 3 files changed, 49 insertions(+), 7 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index f7bea55..886d333 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -3,7 +3,9 @@ class DefaultUser: - user = "admin" + # user = "admin" + user = "akimatc" + admin = "admin" password = "qwerty" diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index c8a92b2..e125bef 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -15,4 +15,7 @@ def login(self, name, password): def change_cool_down_time(self, token, new_value): return self.request_session.put(generate_full_url(Endpoints.cooldowntime), - params={"token": token, "time": new_value}) \ No newline at end of file + params={"token": token, "time": new_value}) + + def get_cool_down_time(self): + return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) \ No newline at end of file diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py index 5e87ba9..29de94c 100644 --- a/tests/functional/tests_cooldowntime.py +++ b/tests/functional/tests_cooldowntime.py @@ -7,20 +7,57 @@ class Test(ApiTestBase): - def test_set_cool_down_time(self): + def test_set_cool_down_time_admin(self): """ Change the cool down time by admin :return: """ - new_CDT = 500000 + new_CDT = self.get_new_cool_down_time(200000, 100000) + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_cool_down_time(token, new_CDT) + + last_req = self.get_cool_down_time() + CDT_after = last_req.json()["content"] + + self.assertEqual(CDT_after, new_CDT) + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + + def test_set_cool_down_time_user(self): + """ + Change the cool down time by user (without admin rights) + :return: + """ + new_CDT = self.get_new_cool_down_time(500000, 100000) + + req = self.get_cool_down_time() + curr_CDT = req.json()["content"] login = self.login(DefaultUser.user, DefaultUser.password) token = login.json()["content"] - # kwargs = {"token": token, "time": new_CDT} req = self.change_cool_down_time(token, new_CDT) - last_req = requests.get(generate_full_url(Endpoints.cooldowntime)) + last_req = self.get_cool_down_time() CDT_after = last_req.json()["content"] - self.assertEqual(CDT_after, new_CDT) \ No newline at end of file + self.assertEqual(req.status_code, 200) + self.assertFalse(req.json()["content"]) + self.assertEqual(CDT_after, curr_CDT) + + def get_new_cool_down_time(self, new_CDT, step): + """ + Get new cool down time (CDT) value. + If current CDT equal new value then we make greater new CDT by step + :return: + """ + req = self.get_cool_down_time() + curr_CDT = req.json()["content"] + + if curr_CDT == new_CDT: + new_CDT = curr_CDT + step + + return new_CDT From b8e114b6f891898a552f63a405458b76f0d54901 Mon Sep 17 00:00:00 2001 From: abertash Date: Sat, 27 Oct 2018 04:56:06 +0300 Subject: [PATCH 12/74] func/init: - Add new functions to get/set token life time. - Add new function to get reset. other: - Add new tests for cool down time (positive, negative, boundary) - Add new file with all tests for token life - refactoring my own files --- tests/functional/__init__.py | 12 +- tests/functional/tests_cooldowntime.py | 140 +++++++++++++++- tests/functional/tests_tokenlifetime.py | 208 ++++++++++++++++++++++++ 3 files changed, 351 insertions(+), 9 deletions(-) create mode 100644 tests/functional/tests_tokenlifetime.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index e125bef..90c0cf0 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -7,6 +7,9 @@ class ApiTestBase(unittest.TestCase): + def get_reset(self): + return self.request_session.get(generate_full_url(Endpoints.reset)) + def setUp(self): self.request_session = requests.session() @@ -18,4 +21,11 @@ def change_cool_down_time(self, token, new_value): params={"token": token, "time": new_value}) def get_cool_down_time(self): - return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) \ No newline at end of file + return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) + + def change_token_life_time(self, token, new_value): + return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), + params={"token": token, "time": new_value}) + + def get_token_life_time(self): + return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) \ No newline at end of file diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py index 29de94c..8898d87 100644 --- a/tests/functional/tests_cooldowntime.py +++ b/tests/functional/tests_cooldowntime.py @@ -1,17 +1,27 @@ -import requests - from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, DefaultUser, Endpoints -from tests.utils.helper import generate_full_url +from tests.constants.constants import DefaultUser class Test(ApiTestBase): - def test_set_cool_down_time_admin(self): + def test_get_cool_down_time(self): """ - Change the cool down time by admin + Get the value of cool down time :return: """ + + req = self.get_cool_down_time() + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.ok) + self.assertTrue(req.json()["content"] or req.json()["content"] == 0) + + def test_set_cool_down_time_admin_positive(self): + """ + Change the cool down time value by admin (positive) + :return: + """ + new_CDT = self.get_new_cool_down_time(200000, 100000) login = self.login(DefaultUser.admin, DefaultUser.password) @@ -22,15 +32,127 @@ def test_set_cool_down_time_admin(self): last_req = self.get_cool_down_time() CDT_after = last_req.json()["content"] + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) self.assertEqual(CDT_after, new_CDT) + + def test_set_cool_down_time_admin_negative(self): + """ + Change the cool down time value by admin (negative) + :return: + """ + + new_CDT = self.get_new_cool_down_time(-200000, -100000) + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_cool_down_time(token, new_CDT) + + last_req = self.get_cool_down_time() + CDT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(CDT_after, new_CDT) + + def test_set_cool_down_time_admin_zero(self): + """ + Change the cool down time value by admin (zero) + :return: + """ + + new_CDT = self.get_new_cool_down_time(0, 0) + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_cool_down_time(token, new_CDT) + + last_req = self.get_cool_down_time() + CDT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(CDT_after, new_CDT) + + def test_set_cool_down_time_admin_none(self): + """ + Change the cool down time value by admin (None) + :return: + """ + + new_CDT = None + def_CDT = 1000 + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_cool_down_time(token, new_CDT) + + last_req = self.get_cool_down_time() + CDT_after = last_req.json()["content"] + self.assertEqual(req.status_code, 200) self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(CDT_after, def_CDT) + + def test_set_cool_down_time_admin_float(self): + """ + Change the cool down time value by admin (float) + :return: + """ + + new_CDT = self.get_new_cool_down_time(200000.555, 100000) + + req = self.get_cool_down_time() + curr_CDT = req.json()["content"] + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_cool_down_time(token, new_CDT) + + last_req = self.get_cool_down_time() + CDT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 400) + self.assertFalse(req.ok) + self.assertEqual(CDT_after, curr_CDT) + + def test_set_cool_down_time_admin_text(self): + """ + Change the cool down time value by admin (text) + :return: + """ + + new_CDT = "f%kdm525!(" + + req = self.get_cool_down_time() + curr_CDT = req.json()["content"] + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_cool_down_time(token, new_CDT) + + last_req = self.get_cool_down_time() + CDT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 400) + self.assertFalse(req.ok) + self.assertEqual(CDT_after, curr_CDT) def test_set_cool_down_time_user(self): """ - Change the cool down time by user (without admin rights) + Change the cool down time value by user (without admin rights) :return: """ + new_CDT = self.get_new_cool_down_time(500000, 100000) req = self.get_cool_down_time() @@ -46,6 +168,7 @@ def test_set_cool_down_time_user(self): self.assertEqual(req.status_code, 200) self.assertFalse(req.json()["content"]) + self.assertTrue(req.ok) self.assertEqual(CDT_after, curr_CDT) def get_new_cool_down_time(self, new_CDT, step): @@ -54,10 +177,11 @@ def get_new_cool_down_time(self, new_CDT, step): If current CDT equal new value then we make greater new CDT by step :return: """ + req = self.get_cool_down_time() curr_CDT = req.json()["content"] if curr_CDT == new_CDT: new_CDT = curr_CDT + step - return new_CDT + return new_CDT \ No newline at end of file diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py new file mode 100644 index 0000000..70e281c --- /dev/null +++ b/tests/functional/tests_tokenlifetime.py @@ -0,0 +1,208 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import DefaultUser + + +class Test(ApiTestBase): + + def test_get_token_life_time(self): + """ + Get the value of token life time + :return: + """ + + req = self.get_token_life_time() + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.ok) + self.assertTrue(req.json()["content"] or req.json()["content"] == 0) + + def test_set_token_life_time_admin_positive(self): + """ + Change the token life time value by admin (positive) + :return: + """ + + # must use, because after et_token_life_time = 0, admin logout + self.get_reset() + + new_TLT = self.get_new_token_life_time(200000, 100000) + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_token_life_time(token, new_TLT) + + last_req = self.get_token_life_time() + TLT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(TLT_after, new_TLT) + + def test_set_token_life_time_admin_negative(self): + """ + Change the token life time value by admin (negative) + :return: + """ + + # must use, because after et_token_life_time = 0, admin logout + self.get_reset() + + new_TLT = self.get_new_token_life_time(-200000, -100000) + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_token_life_time(token, new_TLT) + + last_req = self.get_token_life_time() + TLT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(TLT_after, new_TLT) + + def test_set_token_life_time_admin_zero(self): + """ + Change the token life time value by admin (zero) + :return: + """ + + # must use, because after et_token_life_time = 0, admin logout + self.get_reset() + + new_TLT = self.get_new_token_life_time(0, 0) + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_token_life_time(token, new_TLT) + + last_req = self.get_token_life_time() + TLT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(TLT_after, new_TLT) + + def test_set_token_life_time_admin_none(self): + """ + Change the token life time value by admin (None) + :return: + """ + + # must use, because after et_token_life_time = 0, admin logout + self.get_reset() + + new_TLT = None + def_TLT = 1000 + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_token_life_time(token, new_TLT) + + last_req = self.get_token_life_time() + TLT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(TLT_after, def_TLT) + + def test_set_token_life_time_admin_float(self): + """ + Change the token life time value by admin (float) + :return: + """ + + # must use, because after et_token_life_time = 0, admin logout + self.get_reset() + + new_TLT = self.get_new_token_life_time(200000.555, 100000) + + req = self.get_token_life_time() + curr_TLT = req.json()["content"] + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_token_life_time(token, new_TLT) + + last_req = self.get_token_life_time() + TLT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 400) + self.assertFalse(req.ok) + self.assertEqual(TLT_after, curr_TLT) + + def test_set_token_life_time_admin_text(self): + """ + Change the token life time value by admin (text) + :return: + """ + + # must use, because after et_token_life_time = 0, admin logout + self.get_reset() + + new_TLT = "f%kdm525!(" + + req = self.get_token_life_time() + curr_TLT = req.json()["content"] + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.change_token_life_time(token, new_TLT) + + last_req = self.get_token_life_time() + TLT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 400) + self.assertFalse(req.ok) + self.assertEqual(TLT_after, curr_TLT) + + def test_set_token_life_time_user(self): + """ + Change the token life time value by user (without admin rights) + :return: + """ + + # must use, because after et_token_life_time = 0, admin logout + self.get_reset() + + new_TLT = self.get_new_token_life_time(500000, 100000) + + req = self.get_token_life_time() + curr_TLT = req.json()["content"] + + login = self.login(DefaultUser.user, DefaultUser.password) + token = login.json()["content"] + + req = self.change_token_life_time(token, new_TLT) + + last_req = self.get_token_life_time() + TLT_after = last_req.json()["content"] + + self.assertEqual(req.status_code, 200) + self.assertFalse(req.json()["content"]) + self.assertTrue(req.ok) + self.assertEqual(TLT_after, curr_TLT) + + def get_new_token_life_time(self, new_TLT, step): + """ + Get new token life time (TLT) value. + If current TLT equal new value then we make greater new TLT by step + :return: + """ + + req = self.get_token_life_time() + curr_TLT = req.json()["content"] + + if curr_TLT == new_TLT: + new_TLT = curr_TLT + step + + return new_TLT \ No newline at end of file From 8c88bd14acc8dee4c4861131bf9e340c77707643 Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Sat, 27 Oct 2018 18:49:53 +0300 Subject: [PATCH 13/74] The first attempt of test --- tests/functional/__init__.py | 3 +++ tests/functional/tests_item.py | 19 +++++++++++++++++++ 2 files changed, 22 insertions(+) create mode 100644 tests/functional/tests_item.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 012cf0b..9c8b50c 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -12,3 +12,6 @@ def setUp(self): def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) + + def getUserItems(self, admintoken): + return self.request_session.get("http://localhost:8080/item/user/kilinatc", params={"token": admintoken}) diff --git a/tests/functional/tests_item.py b/tests/functional/tests_item.py new file mode 100644 index 0000000..d59fb5e --- /dev/null +++ b/tests/functional/tests_item.py @@ -0,0 +1,19 @@ +from tests.functional import ApiTestBase + + +class Test(ApiTestBase): + """get user items with admintoken""" + def test_item(self): + login = self.login("admin", "qwerty") + get_items_user = self.getUserItems(login.json()["content"]) + print(get_items_user.content) + self.assertEqual(200, get_items_user.status_code) + self.assertEqual("", get_items_user.json()["content"]) + + """get user items with user token""" + def test_items(self): + login = self.login("kilinatc", "qwerty") + get_items_user = self.getUserItems(login.json()["content"]) + print(get_items_user.content) + self.assertEqual(200, get_items_user.status_code) + self.assertEqual("", get_items_user.json()["content"]) From 0e8fdd38aed6ac69cbf7d7e7f204d9c7247eb4ce Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Sat, 27 Oct 2018 19:05:09 +0300 Subject: [PATCH 14/74] test of locking users completed --- tests/functional/tests_locked.py | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index b64b8c3..fa065e2 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -2,7 +2,7 @@ import requests from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser +from tests.constants.constants import Endpoints, DefaultUser, InitUsers from tests.utils.helper import generate_full_url class TestLocked(ApiTestBase): @@ -20,13 +20,17 @@ def setUp(self): def test_locked(self): """Test functionality of locking users""" passwords = ['voron','password', 'birthday', 'petname'] - for password in passwords: - self.login('khalaktc', password ) - kwargs = {'token': self.adminToken, } + users = list(InitUsers.users) + users.remove('admin') + for user in users: + for password in passwords: + self.login(user, password ) + kwargs = {'token': self.adminToken } locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) locked_users = locked_users_request.json()['content'] - print(locked_users) - self.assertEqual('0', '0') + self.assertEqual(locked_users, + '0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4 \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n') + requests.get(generate_full_url(Endpoints.reset)) def test_not_locked(self): """User should not be locked""" From f6c532fe598ef6544237ec7b37bbe8ff5cdc4141 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Sat, 27 Oct 2018 21:19:23 +0300 Subject: [PATCH 15/74] added 3 positive test, and 1 test with bug --- tests/functional/test_changePass.py | 35 ++++++++++++++++++++++++ tests/functional/test_create_new_user.py | 23 ++++++++++++++++ tests/functional/test_user_get_name.py | 24 ++++++++++++++++ 3 files changed, 82 insertions(+) create mode 100644 tests/functional/test_changePass.py create mode 100644 tests/functional/test_create_new_user.py create mode 100644 tests/functional/test_user_get_name.py diff --git a/tests/functional/test_changePass.py b/tests/functional/test_changePass.py new file mode 100644 index 0000000..83219ef --- /dev/null +++ b/tests/functional/test_changePass.py @@ -0,0 +1,35 @@ +import unittest + +import requests + +from tests.constants.constants import Endpoints, DefaultUser +from tests.functional import ApiTestBase +from tests.utils.helper import generate_full_url + + +class TestLocked(ApiTestBase): + + + def test_change_pass(self): + + """login as user and get token. Do it after creating user""" + + response = self.login("qwert", "qwertyqq") + self.token = response.json()['content'] + + """Create new user""" + + change_pass = requests.put(generate_full_url(Endpoints.user), + params=dict(token=self.token, oldpassword="qwertyqq", newpassword="qwertyqq")) + print(change_pass.text) + self.assertIn("true", change_pass.text,"continue./ all is good") + + """ add spaces in newpassword. but be carefully. it's will change pass in login, and change_pass + if true = it's mean pass sucsessfully changed. but it's error!""" + wrong_change_pass = requests.put(generate_full_url(Endpoints.user), + params={'token': self.token, 'oldpassword':"qwertyqq", 'newpassword':"qwertyqq"}) + print(change_pass.text) + self.assertEqual("true", wrong_change_pass.text, "Error! pass was created with spaces") + +if __name__ == "main__": + unittest.main() diff --git a/tests/functional/test_create_new_user.py b/tests/functional/test_create_new_user.py new file mode 100644 index 0000000..8693f9f --- /dev/null +++ b/tests/functional/test_create_new_user.py @@ -0,0 +1,23 @@ +import unittest +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import Endpoints, DefaultUser +from tests.utils.helper import generate_full_url + + +class TestLocked(ApiTestBase): + + def test_add_User(self): + + """login and get admin token""" + + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + """create new user with admin token, and with rights: ADMIN """ + + create_user = requests.post(generate_full_url(Endpoints.user), + params={'token': self.adminToken, "name": "qwert", + "password": "qwertyqq", "rights": "true"}) + self.assertIn("true", create_user.text) diff --git a/tests/functional/test_user_get_name.py b/tests/functional/test_user_get_name.py new file mode 100644 index 0000000..c61e8fa --- /dev/null +++ b/tests/functional/test_user_get_name.py @@ -0,0 +1,24 @@ +import unittest + +import requests + +from tests.constants.constants import DefaultUser, Endpoints +from tests.functional import ApiTestBase +from tests.utils.helper import generate_full_url + + +class TestLocked(ApiTestBase): + + def test_get_user_name(self): + + """login with admin""" + + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + """get logged user name""" + + get_name = requests.get(generate_full_url(Endpoints.user), params={'token': self.adminToken}) + logged_user_name = get_name.json()['content'] + self.assertIn(DefaultUser.user, logged_user_name) + From 07d659b2c954b60aff34fa8d61cbbd8055a36bfe Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Sun, 28 Oct 2018 11:22:03 +0200 Subject: [PATCH 16/74] changed locked_user in constants to locked_user= "/locked/user/" and item = "/item/" --- tests/constants/constants.py | 4 ++-- tests/functional/tests_locked.py | 36 ++++++++++++++++++++++++++++---- 2 files changed, 34 insertions(+), 6 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index f7bea55..6fe6db5 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -60,10 +60,10 @@ class Endpoints: login_users = "/login/users" login_tockens = "/login/tockens" locked_users = "/locked/users" - locked_user= "/locked/user" + locked_user= "/locked/user/" locked_reset = "/locked/reset" item_user = "/item/user" - item = "/item" + item = "/item/" items = "/items" itemindexes ="/itemindexes" diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index fa065e2..3d67b9f 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -19,21 +19,49 @@ def setUp(self): def test_locked(self): """Test functionality of locking users""" - passwords = ['voron','password', 'birthday', 'petname'] + passwords = ['','password', 'birthday', 'petname'] # number of passwords determines login attemps users = list(InitUsers.users) users.remove('admin') for user in users: for password in passwords: self.login(user, password ) kwargs = {'token': self.adminToken } - locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params = kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, - '0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4 \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n') - requests.get(generate_full_url(Endpoints.reset)) + ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4' + ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) + requests.get(generate_full_url(Endpoints.locked_reset), params = kwargs) def test_not_locked(self): """User should not be locked""" + passwords = ['', 'password', 'qwerty'] + users = list(InitUsers.users) + users.remove('admin') + for user in users: + for password in passwords: + self.login(user, password) + kwargs = {'token': self.adminToken} + logined_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + logined_users = logined_users_request.json()['content'] + manual = (generate_full_url(Endpoints.locked_users) + users[2]) + print(manual) + self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4' + ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) + + def test_manual_lock(self): + '''Test functionality of locking users by manual command''' + pass + + + def test_manual_unlock(self): + '''Test functionality of unlocking users by manual command''' + pass + + + def test_reset_locked(self): + '''Test functionality of unlocking all users''' + pass From 533bfd7a07bab9be9dc1bd417b55d1f9101a93b6 Mon Sep 17 00:00:00 2001 From: abertash Date: Sun, 28 Oct 2018 13:59:00 +0200 Subject: [PATCH 17/74] func/init: - Add new functions to get all users. - Change names of my own params, that must be understandable other: - Add new file with all tests for /users - refactoring my own files --- tests/functional/__init__.py | 13 +++++---- tests/functional/tests_cooldowntime.py | 2 +- tests/functional/tests_tokenlifetime.py | 2 +- tests/functional/tests_users.py | 35 +++++++++++++++++++++++++ 4 files changed, 45 insertions(+), 7 deletions(-) create mode 100644 tests/functional/tests_users.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 90c0cf0..fbdbd33 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -16,16 +16,19 @@ def setUp(self): def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) - def change_cool_down_time(self, token, new_value): + def change_cool_down_time(self, admin_token, new_value): return self.request_session.put(generate_full_url(Endpoints.cooldowntime), - params={"token": token, "time": new_value}) + params={"token": admin_token, "time": new_value}) def get_cool_down_time(self): return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) - def change_token_life_time(self, token, new_value): + def change_token_life_time(self, admin_token, new_value): return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), - params={"token": token, "time": new_value}) + params={"token": admin_token, "time": new_value}) def get_token_life_time(self): - return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) \ No newline at end of file + return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) + + def get_all_users(self, admin_token): + return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) \ No newline at end of file diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py index 8898d87..75a4bfe 100644 --- a/tests/functional/tests_cooldowntime.py +++ b/tests/functional/tests_cooldowntime.py @@ -2,7 +2,7 @@ from tests.constants.constants import DefaultUser -class Test(ApiTestBase): +class TestCoolDownTime(ApiTestBase): def test_get_cool_down_time(self): """ diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py index 70e281c..69ab712 100644 --- a/tests/functional/tests_tokenlifetime.py +++ b/tests/functional/tests_tokenlifetime.py @@ -2,7 +2,7 @@ from tests.constants.constants import DefaultUser -class Test(ApiTestBase): +class TestTokenLifeTime(ApiTestBase): def test_get_token_life_time(self): """ diff --git a/tests/functional/tests_users.py b/tests/functional/tests_users.py new file mode 100644 index 0000000..89b0e7b --- /dev/null +++ b/tests/functional/tests_users.py @@ -0,0 +1,35 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import DefaultUser + + +class TestUsers(ApiTestBase): + + def test_get_all_users_admin(self): + """ + Get the list of all users by admin + :return: + """ + + login = self.login(DefaultUser.admin, DefaultUser.password) + token = login.json()["content"] + + req = self.get_all_users(token) + + self.assertEqual(req.status_code, 200) + self.assertTrue(req.ok) + self.assertTrue(req.json()["content"]) + + def test_get_all_users_user(self): + """ + Get the list of all users by user (without admin rights) + :return: + """ + + login = self.login(DefaultUser.user, DefaultUser.password) + token = login.json()["content"] + + req = self.get_all_users(token) + + self.assertEqual(req.status_code, 200) + self.assertFalse(req.json()["content"]) + self.assertTrue(req.ok) From 08714d5aede450602ed7017c2d065b659d48a308 Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Sun, 28 Oct 2018 15:38:43 +0200 Subject: [PATCH 18/74] add new class tearDown in functional/__init__.py for close request session and reset API and python3 style code fix add new file tests_admins for testing API /admin add new file login for testing API /login add new file logout for testing API /logout --- tests/functional/__init__.py | 11 ++- tests/functional/tests_admins.py | 48 ++++++++++++ tests/functional/tests_login.py | 123 +++++++++++++++++++++++++++++++ tests/functional/tests_logout.py | 49 ++++++++++++ 4 files changed, 230 insertions(+), 1 deletion(-) create mode 100644 tests/functional/tests_admins.py create mode 100644 tests/functional/tests_login.py create mode 100644 tests/functional/tests_logout.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 012cf0b..0e3cc95 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -1,6 +1,8 @@ import unittest import requests +from requests import request + from tests.constants.constants import Endpoints from tests.utils.helper import generate_full_url @@ -10,5 +12,12 @@ class ApiTestBase(unittest.TestCase): def setUp(self): self.request_session = requests.session() - def login(self, name, password): + def login(self, name: str, password: str) -> request: return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) + + def logout(self, name: str, token: str) -> request: + return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) + + def tearDown(self): + self.request_session.get(generate_full_url(Endpoints.reset)) + self.request_session.close() diff --git a/tests/functional/tests_admins.py b/tests/functional/tests_admins.py new file mode 100644 index 0000000..94545b4 --- /dev/null +++ b/tests/functional/tests_admins.py @@ -0,0 +1,48 @@ +""" +Functional tests for admins +""" + +from tests.constants.constants import DefaultUser, Endpoints +from tests.functional import ApiTestBase +from tests.utils.helper import generate_full_url + + +class TestAdmins(ApiTestBase): + + def check_status_code_200(self, status_code: int): + self.assertEqual(status_code, 200, "Error response status code (expected 200)") + + def test_admins(self): + """Get all admins with admin token. If list not empty test pass""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + all_admins = self.request_session.get(generate_full_url(Endpoints.admins), params=token) + self.check_status_code_200(all_admins.status_code) + # print(all_admins.text) + self.assertTrue(all_admins.json().get("content"), "Content is empty") + + def test_admins_users(self): + """Get all admins without admin token. If list empty test pass""" + for user, password in users.items(): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + all_admins = self.request_session.get(generate_full_url(Endpoints.admins), params=token) + self.check_status_code_200(all_admins.status_code) + # print(all_admins.text) + self.assertFalse(all_admins.json().get("content"), "Content is not empty") + + +users = {"akimatc": "qwerty", + "khalaktc": "qwerty", + "kilinatc": "qwerty", + "OKonokhtc": "qwerty", + "otlumtc": "qwerty", + "slototc": "qwerty", + "vbudktc": "qwerty", + "vvasylystc": "qwerty"} diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py new file mode 100644 index 0000000..54d1319 --- /dev/null +++ b/tests/functional/tests_login.py @@ -0,0 +1,123 @@ +""" +Functional tests for logging users +""" + +from tests.constants.constants import DefaultUser, InitUsers, InitInvalidUsers, Endpoints +from tests.functional import ApiTestBase +from tests.utils.helper import generate_full_url + + +class TestLogin(ApiTestBase): + + def check_status_code_200(self, status_code: int): + self.assertEqual(status_code, 200, "Error response status code (expected 200)") + + def test_login(self): + """Logging users. If user got token test pass""" + for user, password in InitUsers.users.items(): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + self.assertEqual(len(login.json().get("content")), 32, "Invalid token") + + def test_login_user_not_found(self): + """Logging fake users. If user not found test pass""" + for user, password in InitInvalidUsers.invalid_users.items(): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + self.assertIn("ERROR, user not found", login.text, "User founded") + + def test_login_user_locked(self): + """Logging 3 times invalid user to lock user. If user locked test pass""" + for user, password in InitInvalidUsers.invalid_users.items(): + for i in range(4): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + self.assertIn("ERROR, user locked", login.text, "User not locked") + + def test_login_admins(self): + """Get logged admins with admin token. If user had admin rights and got the list of logged admins test pass""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + logged_admins = self.request_session.get(generate_full_url(Endpoints.login_admins), params=token) + self.check_status_code_200(logged_admins.status_code) + # print(logged_admins.text) + self.assertTrue(logged_admins.json().get("content"), "Content is empty") + + def test_login_admins_users(self): + """Get logged admins without admin token. If empty response test pass""" + for user, password in users.items(): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + logged_admins = self.request_session.get(generate_full_url(Endpoints.login_admins), params=token) + self.check_status_code_200(logged_admins.status_code) + # print(logged_admins.text) + self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + + def test_login_users_admin(self): + """Get logged users with admin token. If got the list of logged users test pass""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + logged_admins = self.request_session.get(generate_full_url(Endpoints.login_users), params=token) + self.check_status_code_200(logged_admins.status_code) + # print(logged_admins.text) + self.assertTrue(logged_admins.json().get("content"), "Content is empty") + + def test_login_users(self): + """Get logged users without admin token. If list of users empty test pass""" + for user, password in users.items(): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + logged_admins = self.request_session.get(generate_full_url(Endpoints.login_users), params=token) + self.check_status_code_200(logged_admins.status_code) + # print(logged_admins.text) + self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + + def test_login_tockens_admin(self): + """Get alive tockens with admin token. If got list of tokens test pass""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + logged_admins = self.request_session.get(generate_full_url(Endpoints.login_tockens), params=token) + self.check_status_code_200(logged_admins.status_code) + # print(logged_admins.text) + self.assertTrue(logged_admins.json().get("content"), "Content is empty") + + def test_login_tockens_users(self): + """Get alive tockens without admin token. If list of tokens empty test pass""" + for user, password in users.items(): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json() + token["token"] = token.pop("content") + logged_admins = self.request_session.get(generate_full_url(Endpoints.login_tockens), params=token) + self.check_status_code_200(logged_admins.status_code) + # print(logged_admins.text) + self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + + +users = {"akimatc": "qwerty", + "khalaktc": "qwerty", + "kilinatc": "qwerty", + "OKonokhtc": "qwerty", + "otlumtc": "qwerty", + "slototc": "qwerty", + "vbudktc": "qwerty", + "vvasylystc": "qwerty"} diff --git a/tests/functional/tests_logout.py b/tests/functional/tests_logout.py new file mode 100644 index 0000000..63b5404 --- /dev/null +++ b/tests/functional/tests_logout.py @@ -0,0 +1,49 @@ +""" +Functional tests for logout users +""" + +from tests.constants.constants import InitUsers, InitInvalidUsers +from tests.functional import ApiTestBase + + +class TestLogout(ApiTestBase): + + def check_status_code_200(self, status_code: int): + self.assertEqual(status_code, 200, "Error response status code (expected 200)") + + def test_logout(self): + """Logout users. If request true user logout and test pass""" + for user, password in InitUsers.users.items(): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json().get("content") + logout = self.logout(user, token) + self.check_status_code_200(logout.status_code) + # print(logout.text) + self.assertTrue(logout.json().get("content"), "User not logout") + + def test_logout_fake_users(self): + """Logout fake users. If request false user didn't logout and test pass""" + for user, password in InitInvalidUsers.invalid_users.items(): + login = self.login(user, password) + # print(login.text) + self.check_status_code_200(login.status_code) + token = login.json().get("content") + logout = self.logout(user, token) + self.check_status_code_200(logout.status_code) + # print(logout.text) + self.assertFalse(logout.json().get("content"), "User logout") + + def test_logout_locked_users(self): + """Logout locked users. If request false user didn't logout and test pass""" + for user, password in InitInvalidUsers.invalid_users.items(): + for i in range(3): + login = self.login(user, password) + self.check_status_code_200(login.status_code) + # print(login.text) + token = login.json().get("content") + logout = self.logout(user, token) + self.check_status_code_200(logout.status_code) + # print(logout.text) + self.assertFalse(logout.json().get("content"), "User logout") From c723afa84c8b15b539b3d6badcf53c2d944793e8 Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Sun, 28 Oct 2018 18:18:30 +0200 Subject: [PATCH 19/74] Add new tests, methods of item --- tests/constants/constants.py | 9 ++++----- tests/functional/__init__.py | 22 ++++++++++++++++++++-- tests/functional/tests_add_item.py | 23 +++++++++++++++++++++++ tests/functional/tests_delete_item.py | 21 +++++++++++++++++++++ tests/functional/tests_get_item.py | 22 ++++++++++++++++++++++ tests/functional/tests_get_items_user.py | 20 ++++++++++++++++++++ tests/functional/tests_get_user_item.py | 24 ++++++++++++++++++++++++ tests/functional/tests_item.py | 19 ------------------- tests/functional/tests_update_item.py | 23 +++++++++++++++++++++++ 9 files changed, 157 insertions(+), 26 deletions(-) create mode 100644 tests/functional/tests_add_item.py create mode 100644 tests/functional/tests_delete_item.py create mode 100644 tests/functional/tests_get_item.py create mode 100644 tests/functional/tests_get_items_user.py create mode 100644 tests/functional/tests_get_user_item.py delete mode 100644 tests/functional/tests_item.py create mode 100644 tests/functional/tests_update_item.py diff --git a/tests/constants/constants.py b/tests/constants/constants.py index f7bea55..17e410e 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -55,15 +55,14 @@ class Endpoints: tokenlifetime = "/tokenlifetime" admins = "/admins" login_admins = "/login/admins" - locked_admins ="/locked/admins" + locked_admins = "/locked/admins" users = "/users" login_users = "/login/users" login_tockens = "/login/tockens" locked_users = "/locked/users" - locked_user= "/locked/user" + locked_user = "/locked/user" locked_reset = "/locked/reset" - item_user = "/item/user" + item_user = "/item/user/" item = "/item" items = "/items" - itemindexes ="/itemindexes" - + itemindexes = "/itemindexes" diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 9c8b50c..07d1cf4 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -10,8 +10,26 @@ class ApiTestBase(unittest.TestCase): def setUp(self): self.request_session = requests.session() + def reset(self): + return self.request_session.get(generate_full_url(Endpoints.reset)) + def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) - def getUserItems(self, admintoken): - return self.request_session.get("http://localhost:8080/item/user/kilinatc", params={"token": admintoken}) + def get_user_items(self, user, admintoken): + return self.request_session.get("http://localhost:8080/item/user/{name}".format(name=user), params={"token": admintoken}) + + def get_user_item(self, index, user, admintoken): + return self.request_session.get("http://localhost:8080/item/{index}/user/{name}".format(index=index, name=user), params={"token": admintoken}) + + def add_item(self, index, token, item): + return self.request_session.post("http://localhost:8080/item/{index}".format(index=index), params={"token": token, "item": item}) + + def delelete_item(self, index, token): + return self.request_session.delete("http://localhost:8080/item/{index}".format(index=index), params={"token": token}) + + def update_item(self, index, token, item): + return self.request_session.put("http://localhost:8080/item/{index}".format(index=index), params={"token": token, "item": item}) + + def get_item(self, index, token): + return self.request_session.get("http://localhost:8080/item/{index}".format(index=index), params={"token": token}) diff --git a/tests/functional/tests_add_item.py b/tests/functional/tests_add_item.py new file mode 100644 index 0000000..ad19ea4 --- /dev/null +++ b/tests/functional/tests_add_item.py @@ -0,0 +1,23 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers + + +class Test(ApiTestBase): + """test with valid token""" + def test_add_item_positive(self): + counter = 1 + for k, v in dict.items(InitUsers.users): + token = self.login(k, v).json()["content"] + print(token) + add_item_user_responce = self.add_item(counter, token, "Product") + counter = counter + 1 + self.assertEqual(200, add_item_user_responce.status_code) + self.assertTrue(add_item_user_responce.json()["content"]) + self.reset() + + """test with invalid token""" + def test_add_item_negative(self): + token = "2134rfvsd231g45" + add_item_user_response = self.add_item(1, token, "Car") + self.assertEqual(200, add_item_user_response.status_code) + self.assertFalse(add_item_user_response.json()["content"]) diff --git a/tests/functional/tests_delete_item.py b/tests/functional/tests_delete_item.py new file mode 100644 index 0000000..fdb4519 --- /dev/null +++ b/tests/functional/tests_delete_item.py @@ -0,0 +1,21 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers + + +class Test(ApiTestBase): + """delete when users have not any items""" + def test_delete_empty_item(self): + for user, password in dict.items(InitUsers.users): + token = self.login(user, password).json()["content"] + delete_item_response = self.delelete_item(1, token) + self.assertEqual(200, delete_item_response.status_code) + self.assertFalse(delete_item_response.json()["content"]) + + """delete when user has item""" + def test_delete_item(self): + for user, password in dict.items(InitUsers.users): + token = self.login(user, password).json()["content"] + self.add_item(1, token, "Product") + delete_item_response = self.delelete_item(1, token) + self.assertEqual(200, delete_item_response.status_code) + self.assertTrue(delete_item_response.json()["content"]) diff --git a/tests/functional/tests_get_item.py b/tests/functional/tests_get_item.py new file mode 100644 index 0000000..62a84f0 --- /dev/null +++ b/tests/functional/tests_get_item.py @@ -0,0 +1,22 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers + + +class Test(ApiTestBase): + """test when users have not items""" + def test_get_empty_item(self): + for user, password in dict.items(InitUsers.users): + token = self.login(user, password).json()["content"] + get_item_response = self.get_item(1, token) + self.assertEqual(200, get_item_response.status_code) + self.assertFalse(get_item_response.json()["content"]) + + """test when users have item""" + def test_get_item(self): + for user, password in dict.items(InitUsers.users): + token = self.login(user, password).json()["content"] + self.add_item(1, token, "Car") + get_item_response = self.get_item(1, token) + self.assertEqual(200, get_item_response.status_code) + self.assertTrue(get_item_response.json()["content"]) + self.reset() \ No newline at end of file diff --git a/tests/functional/tests_get_items_user.py b/tests/functional/tests_get_items_user.py new file mode 100644 index 0000000..bda843f --- /dev/null +++ b/tests/functional/tests_get_items_user.py @@ -0,0 +1,20 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, DefaultUser + + +class Test(ApiTestBase): + """get user items with admintoken""" + def test_items_admintoken(self): + admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + for k in dict.keys(InitUsers.users): + get_items_user_response = self.get_user_items(k, admintoken) + self.assertEqual(200, get_items_user_response.status_code) + self.assertEqual("", get_items_user_response.json()["content"]) + + """get user items with user token""" + def test_items_usertoken(self): + for k, v in dict.items(InitUsers.users): + token = self.login(k, v).json()["content"] + get_items_user_response = self.get_user_items(k, token) + self.assertEqual(200, get_items_user_response.status_code) + self.assertEqual("", get_items_user_response.json()["content"]) diff --git a/tests/functional/tests_get_user_item.py b/tests/functional/tests_get_user_item.py new file mode 100644 index 0000000..acee498 --- /dev/null +++ b/tests/functional/tests_get_user_item.py @@ -0,0 +1,24 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, DefaultUser + + +class Test(ApiTestBase): + """get user item with admin token""" + def test_get_user_item_byadmin(self): + admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + counter = 1 + for user in dict.keys(InitUsers.users): + get_item_user_response = self.get_user_item(counter, user, admintoken) + counter = counter + 1 + self.assertEqual(200, get_item_user_response.status_code) + self.assertEqual("", get_item_user_response.json()["content"]) + + """get user item with user token""" + def test_get_user_item_byuser(self): + counter = 0 + for k, v in dict.items(InitUsers.users): + token = self.login(k, v).json()["content"] + get_item_user_response = self.get_user_item(counter, k, token) + counter = counter + 1 + self.assertEqual(200, get_item_user_response.status_code) + self.assertEqual("", get_item_user_response.json()["content"]) diff --git a/tests/functional/tests_item.py b/tests/functional/tests_item.py deleted file mode 100644 index d59fb5e..0000000 --- a/tests/functional/tests_item.py +++ /dev/null @@ -1,19 +0,0 @@ -from tests.functional import ApiTestBase - - -class Test(ApiTestBase): - """get user items with admintoken""" - def test_item(self): - login = self.login("admin", "qwerty") - get_items_user = self.getUserItems(login.json()["content"]) - print(get_items_user.content) - self.assertEqual(200, get_items_user.status_code) - self.assertEqual("", get_items_user.json()["content"]) - - """get user items with user token""" - def test_items(self): - login = self.login("kilinatc", "qwerty") - get_items_user = self.getUserItems(login.json()["content"]) - print(get_items_user.content) - self.assertEqual(200, get_items_user.status_code) - self.assertEqual("", get_items_user.json()["content"]) diff --git a/tests/functional/tests_update_item.py b/tests/functional/tests_update_item.py new file mode 100644 index 0000000..a840f40 --- /dev/null +++ b/tests/functional/tests_update_item.py @@ -0,0 +1,23 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers + + +class Test(ApiTestBase): + """test update item when users has no item""" + def test_update_empty_item(self): + self.reset() + for user, password in dict.items(InitUsers.users): + token = self.login(user, password).json()["content"] + update_item_response = self.update_item(1, token, "Product") + self.assertEqual(200, update_item_response.status_code) + self.assertFalse(update_item_response.json()["content"]) + + """test update item when users have item""" + def test_update_item(self): + for user, password in dict.items(InitUsers.users): + token = self.login(user, password).json()["content"] + self.add_item(1, token, "Car") + update_item_response = self.update_item(1, token, "Product") + self.assertEqual(200, update_item_response.status_code) + self.assertTrue(update_item_response.json()["content"]) + self.reset() From 7b123c7ac811ae32c6cb89a3b68fa51d998a4d36 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Sun, 28 Oct 2018 20:58:21 +0200 Subject: [PATCH 20/74] edited previous files, addednew tests for creating user and removing --- tests/functional/test_changePass.py | 15 +++++------ tests/functional/test_create_new_user.py | 16 +++++------ .../test_create_new_user_with_invalid_name.py | 21 +++++++++++++++ .../test_create_new_user_with_invalid_pass.py | 21 +++++++++++++++ tests/functional/test_remove_user.py | 27 +++++++++++++++++++ tests/functional/test_user_get_name.py | 5 ++-- 6 files changed, 86 insertions(+), 19 deletions(-) create mode 100644 tests/functional/test_create_new_user_with_invalid_name.py create mode 100644 tests/functional/test_create_new_user_with_invalid_pass.py create mode 100644 tests/functional/test_remove_user.py diff --git a/tests/functional/test_changePass.py b/tests/functional/test_changePass.py index 83219ef..fb554d3 100644 --- a/tests/functional/test_changePass.py +++ b/tests/functional/test_changePass.py @@ -7,7 +7,7 @@ from tests.utils.helper import generate_full_url -class TestLocked(ApiTestBase): +class TestChangePass(ApiTestBase): def test_change_pass(self): @@ -21,15 +21,14 @@ def test_change_pass(self): change_pass = requests.put(generate_full_url(Endpoints.user), params=dict(token=self.token, oldpassword="qwertyqq", newpassword="qwertyqq")) - print(change_pass.text) + self.assertIn("true", change_pass.text,"continue./ all is good") - """ add spaces in newpassword. but be carefully. it's will change pass in login, and change_pass - if true = it's mean pass sucsessfully changed. but it's error!""" +# add spaces in newpassword. but be carefully. it's will change pass in login, and change_pass +# if true = it's mean pass sucsessfully changed. but it's error! wrong_change_pass = requests.put(generate_full_url(Endpoints.user), params={'token': self.token, 'oldpassword':"qwertyqq", 'newpassword':"qwertyqq"}) - print(change_pass.text) - self.assertEqual("true", wrong_change_pass.text, "Error! pass was created with spaces") -if __name__ == "main__": - unittest.main() + self.assertNotIn("True", str(wrong_change_pass.json()['content']), "Error! pass was created with spaces") + + diff --git a/tests/functional/test_create_new_user.py b/tests/functional/test_create_new_user.py index 8693f9f..e1b2500 100644 --- a/tests/functional/test_create_new_user.py +++ b/tests/functional/test_create_new_user.py @@ -1,4 +1,3 @@ -import unittest import requests from tests.functional import ApiTestBase @@ -6,18 +5,19 @@ from tests.utils.helper import generate_full_url -class TestLocked(ApiTestBase): - - def test_add_User(self): - - """login and get admin token""" +class TestCreateNewUser(ApiTestBase): + def setUp(self): + """Return admin token""" + super().setUp() response = self.login(DefaultUser.user, DefaultUser.password) self.adminToken = response.json()['content'] - """create new user with admin token, and with rights: ADMIN """ + def test_add_User_with_valid_data(self): + + """login and get admin token""" create_user = requests.post(generate_full_url(Endpoints.user), - params={'token': self.adminToken, "name": "qwert", + params={'token': self.adminToken, "name": "validtest", "password": "qwertyqq", "rights": "true"}) self.assertIn("true", create_user.text) diff --git a/tests/functional/test_create_new_user_with_invalid_name.py b/tests/functional/test_create_new_user_with_invalid_name.py new file mode 100644 index 0000000..4a0c73d --- /dev/null +++ b/tests/functional/test_create_new_user_with_invalid_name.py @@ -0,0 +1,21 @@ +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import Endpoints, DefaultUser +from tests.utils.helper import generate_full_url + + +class TestCreateNewUserWithInvalidName(ApiTestBase): + + def setUp(self): + """Return admin token""" + super().setUp() + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + def test_create_User_with_invalid_username(self): + """creating user with spaces""" + create_user_vith_invalid_pass = requests.post(generate_full_url(Endpoints.user), + params={'token': self.adminToken, "name": "invalidtestname ", + "password": "test ", "rights": "false"}) + self.assertNotIn('true', create_user_vith_invalid_pass.text, "error, username have spaces") diff --git a/tests/functional/test_create_new_user_with_invalid_pass.py b/tests/functional/test_create_new_user_with_invalid_pass.py new file mode 100644 index 0000000..c03bf8f --- /dev/null +++ b/tests/functional/test_create_new_user_with_invalid_pass.py @@ -0,0 +1,21 @@ +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import Endpoints, DefaultUser +from tests.utils.helper import generate_full_url + + +class TestCreateNewUserWithInvalidPass(ApiTestBase): + + def setUp(self): + """Return admin token""" + super().setUp() + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + def test_create_User_with_invalid_pass(self): + """creating user with spaces""" + create_user_vith_invalid_pass = requests.post(generate_full_url(Endpoints.user), + params={'token': self.adminToken, "name": "invalidtestpass", + "password": "test ", "rights": "false"}) + self.assertNotIn('true', create_user_vith_invalid_pass.text, "error, pass have spaces") diff --git a/tests/functional/test_remove_user.py b/tests/functional/test_remove_user.py new file mode 100644 index 0000000..1988348 --- /dev/null +++ b/tests/functional/test_remove_user.py @@ -0,0 +1,27 @@ +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import Endpoints, DefaultUser +from tests.utils.helper import generate_full_url + + +class TestRemoveUser(ApiTestBase): + + def setUp(self): + super().setUp() + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + def test_remove_User_with_valid_data(self): + # create test_user + requests.post(generate_full_url(Endpoints.user), params={'token': self.adminToken, "name": "testuser", + "password": "test ", "rights": "false"}) + # delete test user + remove_created_user = requests.post(generate_full_url(Endpoints.user), + params={'token': self.adminToken, "name": "testuser"}) + self.assertIn("true", remove_created_user.text) + + # valid test = true + # nsatupnyi robutu invalid with NotIn for invalid data usage + # use invalid username + # delete same username 2 times and more. diff --git a/tests/functional/test_user_get_name.py b/tests/functional/test_user_get_name.py index c61e8fa..871bfa5 100644 --- a/tests/functional/test_user_get_name.py +++ b/tests/functional/test_user_get_name.py @@ -1,4 +1,3 @@ -import unittest import requests @@ -7,7 +6,7 @@ from tests.utils.helper import generate_full_url -class TestLocked(ApiTestBase): +class TestGetUserName(ApiTestBase): def test_get_user_name(self): @@ -16,7 +15,7 @@ def test_get_user_name(self): response = self.login(DefaultUser.user, DefaultUser.password) self.adminToken = response.json()['content'] - """get logged user name""" +#get logged user name get_name = requests.get(generate_full_url(Endpoints.user), params={'token': self.adminToken}) logged_user_name = get_name.json()['content'] From 994e6dc7922895026ba978dc74c571838aef8518 Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Mon, 29 Oct 2018 00:49:05 +0200 Subject: [PATCH 21/74] saving work --- tests/functional/tests_locked.py | 71 ++++++++++++++++++++------------ 1 file changed, 44 insertions(+), 27 deletions(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 3d67b9f..76381c8 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -1,12 +1,11 @@ -import unittest import requests from tests.functional import ApiTestBase from tests.constants.constants import Endpoints, DefaultUser, InitUsers from tests.utils.helper import generate_full_url -class TestLocked(ApiTestBase): +class TestLocked(ApiTestBase): def setUp(self): """Return admin token""" @@ -14,24 +13,21 @@ def setUp(self): response = self.login(DefaultUser.user, DefaultUser.password) self.adminToken = response.json()['content'] - - - def test_locked(self): """Test functionality of locking users""" - passwords = ['','password', 'birthday', 'petname'] # number of passwords determines login attemps + passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps users = list(InitUsers.users) users.remove('admin') for user in users: for password in passwords: - self.login(user, password ) - kwargs = {'token': self.adminToken } - locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params = kwargs) + self.login(user, password) + kwargs = {'token': self.adminToken} + locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4' ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) - requests.get(generate_full_url(Endpoints.locked_reset), params = kwargs) + requests.get(generate_full_url(Endpoints.reset)) # reset api def test_not_locked(self): """User should not be locked""" @@ -42,28 +38,49 @@ def test_not_locked(self): for password in passwords: self.login(user, password) kwargs = {'token': self.adminToken} - logined_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + logined_users_request = requests.get(generate_full_url(Endpoints.login_users), params=kwargs) logined_users = logined_users_request.json()['content'] - manual = (generate_full_url(Endpoints.locked_users) + users[2]) - print(manual) - self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4' + print(repr(logined_users)) + self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tadmin\n4' ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) def test_manual_lock(self): - '''Test functionality of locking users by manual command''' - pass - + """Test functionality of locking users by manual command""" + users = list(InitUsers.users) + users.remove('admin') + kwargs = {'token': self.adminToken, 'name': users[1]} + requests.post((generate_full_url(Endpoints.locked_user) + users[1]), params=kwargs) + locked_users_request1 = requests.get(generate_full_url(Endpoints.locked_users), + params={'token': self.adminToken}) + locked_users = locked_users_request1.json()['content'] + s = '0 \t' + users[1] + '\n' + self.assertEqual(locked_users, s ) def test_manual_unlock(self): - '''Test functionality of unlocking users by manual command''' - pass - + """Test functionality of unlocking users by manual command""" + users = list(InitUsers.users) + users.remove('admin') + passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps + for password in passwords: + self.login(users[3], password) + kwargs = {'token': self.adminToken, 'name': users[3]} + requests.put((generate_full_url(Endpoints.locked_user) + users[3]), params=kwargs) + locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), + params={'token': self.adminToken}) + locked_users = locked_users_request.text + if users[3] in locked_users: + self.assertTrue(False) def test_reset_locked(self): - '''Test functionality of unlocking all users''' - pass - - - - - + """Test functionality of unlocking all users""" + passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps + users = list(InitUsers.users) + users.remove('admin') + for user in users: + for password in passwords: + self.login(user, password) + kwargs = {'token': self.adminToken} + requests.put(generate_full_url(Endpoints.locked_reset), params=kwargs) + locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users = locked_users_request.json()['content'] + self.assertEqual(locked_users, '') \ No newline at end of file From 77ac2a7bdbce8101d19d67b19f861957f303ca49 Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Mon, 29 Oct 2018 00:52:40 +0200 Subject: [PATCH 22/74] saving work --- tests/functional/tests_locked.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 76381c8..4620166 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -40,7 +40,7 @@ def test_not_locked(self): kwargs = {'token': self.adminToken} logined_users_request = requests.get(generate_full_url(Endpoints.login_users), params=kwargs) logined_users = logined_users_request.json()['content'] - print(repr(logined_users)) + #print(repr(logined_users)) self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tadmin\n4' ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) From 3b585f9fa3a8825e51fd2a6dd3b6e547b4048d28 Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Mon, 29 Oct 2018 00:57:59 +0200 Subject: [PATCH 23/74] saving work --- tests/functional/__init__.py | 2 +- tests/functional/tests_locked.py | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 5bfba9f..532e035 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -12,5 +12,5 @@ class ApiTestBase(unittest.TestCase): def setUp(self): self.request_session = requests.session() - def login(self, name:str, password:str) -> response: + def login(self, name:str, password:str) -> object: return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 4620166..ed86b59 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -40,7 +40,7 @@ def test_not_locked(self): kwargs = {'token': self.adminToken} logined_users_request = requests.get(generate_full_url(Endpoints.login_users), params=kwargs) logined_users = logined_users_request.json()['content'] - #print(repr(logined_users)) + # print(repr(logined_users)) self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tadmin\n4' ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) @@ -54,7 +54,7 @@ def test_manual_lock(self): params={'token': self.adminToken}) locked_users = locked_users_request1.json()['content'] s = '0 \t' + users[1] + '\n' - self.assertEqual(locked_users, s ) + self.assertEqual(locked_users, s) def test_manual_unlock(self): """Test functionality of unlocking users by manual command""" @@ -66,7 +66,7 @@ def test_manual_unlock(self): kwargs = {'token': self.adminToken, 'name': users[3]} requests.put((generate_full_url(Endpoints.locked_user) + users[3]), params=kwargs) locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), - params={'token': self.adminToken}) + params={'token': self.adminToken}) locked_users = locked_users_request.text if users[3] in locked_users: self.assertTrue(False) @@ -83,4 +83,4 @@ def test_reset_locked(self): requests.put(generate_full_url(Endpoints.locked_reset), params=kwargs) locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) locked_users = locked_users_request.json()['content'] - self.assertEqual(locked_users, '') \ No newline at end of file + self.assertEqual(locked_users, '') From 90e41ff1346f941bbea06d38ab5bae928a928aa5 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Mon, 29 Oct 2018 08:03:29 +0200 Subject: [PATCH 24/74] edited remove user --- tests/functional/test_remove_user.py | 5 ----- 1 file changed, 5 deletions(-) diff --git a/tests/functional/test_remove_user.py b/tests/functional/test_remove_user.py index 1988348..6ea28ca 100644 --- a/tests/functional/test_remove_user.py +++ b/tests/functional/test_remove_user.py @@ -20,8 +20,3 @@ def test_remove_User_with_valid_data(self): remove_created_user = requests.post(generate_full_url(Endpoints.user), params={'token': self.adminToken, "name": "testuser"}) self.assertIn("true", remove_created_user.text) - - # valid test = true - # nsatupnyi robutu invalid with NotIn for invalid data usage - # use invalid username - # delete same username 2 times and more. From a7cced033b892e0df9ccbfed805bfc90a58b1404 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Mon, 29 Oct 2018 09:55:34 +0200 Subject: [PATCH 25/74] added new tests (change pass and change pass with invalid data) --- tests/functional/test_changePass.py | 34 ------------------- tests/functional/test_remove_user.py | 20 ++++++++--- tests/functional/test_user_change_pass.py | 0 ...test_user_change_pass_with_invalid_data.py | 31 +++++++++++++++++ ...te_new_user.py => test_user_create_new.py} | 0 ...test_user_create_new_with_invalid_name.py} | 0 ...test_user_create_new_with_invalid_pass.py} | 0 7 files changed, 46 insertions(+), 39 deletions(-) delete mode 100644 tests/functional/test_changePass.py create mode 100644 tests/functional/test_user_change_pass.py create mode 100644 tests/functional/test_user_change_pass_with_invalid_data.py rename tests/functional/{test_create_new_user.py => test_user_create_new.py} (100%) rename tests/functional/{test_create_new_user_with_invalid_name.py => test_user_create_new_with_invalid_name.py} (100%) rename tests/functional/{test_create_new_user_with_invalid_pass.py => test_user_create_new_with_invalid_pass.py} (100%) diff --git a/tests/functional/test_changePass.py b/tests/functional/test_changePass.py deleted file mode 100644 index fb554d3..0000000 --- a/tests/functional/test_changePass.py +++ /dev/null @@ -1,34 +0,0 @@ -import unittest - -import requests - -from tests.constants.constants import Endpoints, DefaultUser -from tests.functional import ApiTestBase -from tests.utils.helper import generate_full_url - - -class TestChangePass(ApiTestBase): - - - def test_change_pass(self): - - """login as user and get token. Do it after creating user""" - - response = self.login("qwert", "qwertyqq") - self.token = response.json()['content'] - - """Create new user""" - - change_pass = requests.put(generate_full_url(Endpoints.user), - params=dict(token=self.token, oldpassword="qwertyqq", newpassword="qwertyqq")) - - self.assertIn("true", change_pass.text,"continue./ all is good") - -# add spaces in newpassword. but be carefully. it's will change pass in login, and change_pass -# if true = it's mean pass sucsessfully changed. but it's error! - wrong_change_pass = requests.put(generate_full_url(Endpoints.user), - params={'token': self.token, 'oldpassword':"qwertyqq", 'newpassword':"qwertyqq"}) - - self.assertNotIn("True", str(wrong_change_pass.json()['content']), "Error! pass was created with spaces") - - diff --git a/tests/functional/test_remove_user.py b/tests/functional/test_remove_user.py index 6ea28ca..acd20bd 100644 --- a/tests/functional/test_remove_user.py +++ b/tests/functional/test_remove_user.py @@ -14,9 +14,19 @@ def setUp(self): def test_remove_User_with_valid_data(self): # create test_user - requests.post(generate_full_url(Endpoints.user), params={'token': self.adminToken, "name": "testuser", - "password": "test ", "rights": "false"}) - # delete test user - remove_created_user = requests.post(generate_full_url(Endpoints.user), - params={'token': self.adminToken, "name": "testuser"}) + creating = requests.post(generate_full_url(Endpoints.user), params={'token': self.adminToken, "name": "testuserdelete", + "password": "qwerty", "rights": "false"}) + print (creating.json()) + #delete test user + remove_created_user = requests.delete(generate_full_url(Endpoints.user), + params={'token': self.adminToken, "name": "testuserdelete"}) + print(remove_created_user.json()) self.assertIn("true", remove_created_user.text) + + try to login with deleted user + def test_login_deleted_user(self): + deleted_user_login = requests.post(generate_full_url(Endpoints.login), + params = {"name": "testuserdelete", "password": "qwerty"}) + self.assertIn("ERROR", deleted_user_login.text, "Error, user not deleted") + + diff --git a/tests/functional/test_user_change_pass.py b/tests/functional/test_user_change_pass.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/functional/test_user_change_pass_with_invalid_data.py b/tests/functional/test_user_change_pass_with_invalid_data.py new file mode 100644 index 0000000..5deb8a0 --- /dev/null +++ b/tests/functional/test_user_change_pass_with_invalid_data.py @@ -0,0 +1,31 @@ +import requests + +from tests.constants.constants import Endpoints, DefaultUser +from tests.functional import ApiTestBase +from tests.utils.helper import generate_full_url + + +class TestChangePass(ApiTestBase): + def setUp(self): + """get admin token""" + super().setUp() + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + def test_add_User_with_valid_data(self): + # create user + + user = requests.post(generate_full_url(Endpoints.user), + params={'token': self.adminToken, "name": "testusero", "password": "qwertyqq", + "rights": "false"}) + + # login with new user + login_with_new_user = requests.post(generate_full_url(Endpoints.login), + params={"name": "testusero", "password": "qwertyqq"}) + token = login_with_new_user.json()['content'] + + # change pass with invalid spaces + change_pass = requests.put(generate_full_url(Endpoints.user), + params={"token": token, "oldpassword": "qwertyqq", "newpassword": "qwerto "}) + self.assertNotIn("true", change_pass.text, "error, pass was changed, and have spaces") + diff --git a/tests/functional/test_create_new_user.py b/tests/functional/test_user_create_new.py similarity index 100% rename from tests/functional/test_create_new_user.py rename to tests/functional/test_user_create_new.py diff --git a/tests/functional/test_create_new_user_with_invalid_name.py b/tests/functional/test_user_create_new_with_invalid_name.py similarity index 100% rename from tests/functional/test_create_new_user_with_invalid_name.py rename to tests/functional/test_user_create_new_with_invalid_name.py diff --git a/tests/functional/test_create_new_user_with_invalid_pass.py b/tests/functional/test_user_create_new_with_invalid_pass.py similarity index 100% rename from tests/functional/test_create_new_user_with_invalid_pass.py rename to tests/functional/test_user_create_new_with_invalid_pass.py From ef21736030acbdc7df8e51b4bf7e01a5a503dc47 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Mon, 29 Oct 2018 09:58:06 +0200 Subject: [PATCH 26/74] just rename file --- tests/functional/{test_remove_user.py => test_user_remove.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename tests/functional/{test_remove_user.py => test_user_remove.py} (100%) diff --git a/tests/functional/test_remove_user.py b/tests/functional/test_user_remove.py similarity index 100% rename from tests/functional/test_remove_user.py rename to tests/functional/test_user_remove.py From a19ef48a13ded691a13cc70635a4e270e84761b7 Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Mon, 29 Oct 2018 11:10:59 +0200 Subject: [PATCH 27/74] tests for all items method, changes constants file, add to __init__.py --- tests/constants/constants.py | 8 +++++ tests/functional/__init__.py | 26 ++++++++++---- tests/functional/tests_add_item.py | 36 +++++++++++-------- tests/functional/tests_all_items.py | 26 ++++++++++++++ tests/functional/tests_delete_item.py | 38 +++++++++++++-------- tests/functional/tests_get_item.py | 22 ------------ tests/functional/tests_get_item_by_index.py | 26 ++++++++++++++ tests/functional/tests_get_itemindexes.py | 23 +++++++++++++ tests/functional/tests_get_items_user.py | 29 +++++++++------- tests/functional/tests_get_user_item.py | 23 +++++++------ tests/functional/tests_update_item.py | 15 ++++---- 11 files changed, 183 insertions(+), 89 deletions(-) create mode 100644 tests/functional/tests_all_items.py delete mode 100644 tests/functional/tests_get_item.py create mode 100644 tests/functional/tests_get_item_by_index.py create mode 100644 tests/functional/tests_get_itemindexes.py diff --git a/tests/constants/constants.py b/tests/constants/constants.py index 17e410e..b8634a7 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -10,6 +10,7 @@ class DefaultUser: class DefaultToken: token = "0123456789ABCDEF0123456789ABCDEF" + invalid_token = "2134rfvsd231g45" class DefaultItem: @@ -22,6 +23,9 @@ class DefaultNum: num = 1000 +VALID_STATUS_CODE = 200 + + class DefaultBool: bool = False @@ -66,3 +70,7 @@ class Endpoints: item = "/item" items = "/items" itemindexes = "/itemindexes" + + +ITEM_NAMES = ["Product", "Car", "Soap", "TV", "Wine", "Tea", "Coffee", "Bread", "apple", "laptop", + "fish", "cat", "dog", "pineapple", "phone", "number1", "number2"] diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 07d1cf4..75c5bfd 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -17,19 +17,31 @@ def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) def get_user_items(self, user, admintoken): - return self.request_session.get("http://localhost:8080/item/user/{name}".format(name=user), params={"token": admintoken}) + return self.request_session.get("http://localhost:8080/item/user/{name}".format(name=user), + params={"token": admintoken}) def get_user_item(self, index, user, admintoken): - return self.request_session.get("http://localhost:8080/item/{index}/user/{name}".format(index=index, name=user), params={"token": admintoken}) + return self.request_session.get("http://localhost:8080/item/{index}/user/{name}".format(index=index, name=user), + params={"token": admintoken}) def add_item(self, index, token, item): - return self.request_session.post("http://localhost:8080/item/{index}".format(index=index), params={"token": token, "item": item}) + return self.request_session.post("http://localhost:8080/item/{index}".format(index=index), + params={"token": token, "item": item}) - def delelete_item(self, index, token): - return self.request_session.delete("http://localhost:8080/item/{index}".format(index=index), params={"token": token}) + def delete_item(self, index, token): + return self.request_session.delete("http://localhost:8080/item/{index}".format(index=index), + params={"token": token}) def update_item(self, index, token, item): - return self.request_session.put("http://localhost:8080/item/{index}".format(index=index), params={"token": token, "item": item}) + return self.request_session.put("http://localhost:8080/item/{index}".format(index=index), + params={"token": token, "item": item}) def get_item(self, index, token): - return self.request_session.get("http://localhost:8080/item/{index}".format(index=index), params={"token": token}) + return self.request_session.get("http://localhost:8080/item/{index}".format(index=index), + params={"token": token}) + + def get_itemindexes(self, token): + return self.request_session.get(generate_full_url(Endpoints.itemindexes), params={"token": token}) + + def get_all_items(self, token): + return self.request_session.get(generate_full_url(Endpoints.items), params={"token": token}) diff --git a/tests/functional/tests_add_item.py b/tests/functional/tests_add_item.py index ad19ea4..728beab 100644 --- a/tests/functional/tests_add_item.py +++ b/tests/functional/tests_add_item.py @@ -1,23 +1,29 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers +from random import choice, randint +from tests.constants.constants import InitUsers, DefaultToken, VALID_STATUS_CODE, ITEM_NAMES -class Test(ApiTestBase): - """test with valid token""" +item_index = randint(0, 1000) +item_name = choice(ITEM_NAMES) + + +class TestAddItem(ApiTestBase): + def test_add_item_positive(self): - counter = 1 - for k, v in dict.items(InitUsers.users): - token = self.login(k, v).json()["content"] - print(token) - add_item_user_responce = self.add_item(counter, token, "Product") - counter = counter + 1 - self.assertEqual(200, add_item_user_responce.status_code) - self.assertTrue(add_item_user_responce.json()["content"]) + """test with valid token""" + counter = 0 + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + add_item_user_response = self.add_item(counter, token, item_name) + counter = counter + 1 + self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) + self.assertTrue(add_item_user_response.json()["content"]) self.reset() - """test with invalid token""" def test_add_item_negative(self): - token = "2134rfvsd231g45" - add_item_user_response = self.add_item(1, token, "Car") - self.assertEqual(200, add_item_user_response.status_code) + """test with invalid token""" + token = DefaultToken.invalid_token + add_item_user_response = self.add_item(item_index, token, item_name) + self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertFalse(add_item_user_response.json()["content"]) diff --git a/tests/functional/tests_all_items.py b/tests/functional/tests_all_items.py new file mode 100644 index 0000000..5d69273 --- /dev/null +++ b/tests/functional/tests_all_items.py @@ -0,0 +1,26 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, VALID_STATUS_CODE + + +class TestAllItems(ApiTestBase): + + def test_without_items(self): + """test when users have not any items""" + self.reset() + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + get_all_items_response = self.get_all_items(token) + self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) + self.assertFalse(get_all_items_response.json()["content"]) + + def test_with_items(self): + """test when users have items""" + self.reset() + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + self.add_item(1, token, "Product") + self.add_item(2, token, "Car") + get_all_items_response = self.get_all_items(token) + self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) + self.assertNotEqual("", get_all_items_response.json()["content"]) + self.reset() diff --git a/tests/functional/tests_delete_item.py b/tests/functional/tests_delete_item.py index fdb4519..9b284c5 100644 --- a/tests/functional/tests_delete_item.py +++ b/tests/functional/tests_delete_item.py @@ -1,21 +1,31 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers +from random import randint, choice +from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES + + +item_name = choice(ITEM_NAMES) +item_index = randint(0, 1000) class Test(ApiTestBase): - """delete when users have not any items""" + def test_delete_empty_item(self): - for user, password in dict.items(InitUsers.users): - token = self.login(user, password).json()["content"] - delete_item_response = self.delelete_item(1, token) - self.assertEqual(200, delete_item_response.status_code) - self.assertFalse(delete_item_response.json()["content"]) + """delete when users have not any items""" + self.reset() + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + delete_item_response = self.delete_item(item_index, token) + self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) + self.assertFalse(delete_item_response.json()["content"]) - """delete when user has item""" def test_delete_item(self): - for user, password in dict.items(InitUsers.users): - token = self.login(user, password).json()["content"] - self.add_item(1, token, "Product") - delete_item_response = self.delelete_item(1, token) - self.assertEqual(200, delete_item_response.status_code) - self.assertTrue(delete_item_response.json()["content"]) + """delete when user has item""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + delete_item_response = self.delete_item(item_index, token) + self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) + self.assertTrue(delete_item_response.json()["content"]) + self.reset() diff --git a/tests/functional/tests_get_item.py b/tests/functional/tests_get_item.py deleted file mode 100644 index 62a84f0..0000000 --- a/tests/functional/tests_get_item.py +++ /dev/null @@ -1,22 +0,0 @@ -from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers - - -class Test(ApiTestBase): - """test when users have not items""" - def test_get_empty_item(self): - for user, password in dict.items(InitUsers.users): - token = self.login(user, password).json()["content"] - get_item_response = self.get_item(1, token) - self.assertEqual(200, get_item_response.status_code) - self.assertFalse(get_item_response.json()["content"]) - - """test when users have item""" - def test_get_item(self): - for user, password in dict.items(InitUsers.users): - token = self.login(user, password).json()["content"] - self.add_item(1, token, "Car") - get_item_response = self.get_item(1, token) - self.assertEqual(200, get_item_response.status_code) - self.assertTrue(get_item_response.json()["content"]) - self.reset() \ No newline at end of file diff --git a/tests/functional/tests_get_item_by_index.py b/tests/functional/tests_get_item_by_index.py new file mode 100644 index 0000000..7d2abb5 --- /dev/null +++ b/tests/functional/tests_get_item_by_index.py @@ -0,0 +1,26 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, VALID_STATUS_CODE + + +class Test(ApiTestBase): + + def test_get_empty_item(self): + """test when users have not items""" + self.reset() + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + get_item_response = self.get_item(1, token) + self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) + self.assertFalse(get_item_response.json()["content"]) + + def test_get_item(self): + """test when users have item""" + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + self.add_item(1, token, "Car") + get_item_response = self.get_item(1, token) + self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) + self.assertTrue(get_item_response.json()["content"]) + self.assertEqual("Car", get_item_response.json()["content"]) + self.reset() diff --git a/tests/functional/tests_get_itemindexes.py b/tests/functional/tests_get_itemindexes.py new file mode 100644 index 0000000..3b7ab90 --- /dev/null +++ b/tests/functional/tests_get_itemindexes.py @@ -0,0 +1,23 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, VALID_STATUS_CODE + + +class Test(ApiTestBase): + def test_get_empty_itemindexes(self): + self.reset() + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + get_itemindexes_response = self.get_itemindexes(token) + self.assertEqual(VALID_STATUS_CODE, get_itemindexes_response.status_code) + self.assertEqual("", get_itemindexes_response.json()["content"]) + + def test_get_itemindexes(self): + self.reset() + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + self.add_item(3, token, "Product") + get_itemindexes_response = self.get_itemindexes(token) + self.assertEqual(VALID_STATUS_CODE, get_itemindexes_response.status_code) + self.assertNotEqual("", get_itemindexes_response.json()["content"]) + self.assertEqual("3 ", get_itemindexes_response.json()["content"]) + self.reset() diff --git a/tests/functional/tests_get_items_user.py b/tests/functional/tests_get_items_user.py index bda843f..cadece0 100644 --- a/tests/functional/tests_get_items_user.py +++ b/tests/functional/tests_get_items_user.py @@ -1,20 +1,23 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, DefaultUser +from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE class Test(ApiTestBase): - """get user items with admintoken""" - def test_items_admintoken(self): + + def test_get_items_by_admin(self): + """get user items with admintoken""" + self.reset() admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] - for k in dict.keys(InitUsers.users): - get_items_user_response = self.get_user_items(k, admintoken) - self.assertEqual(200, get_items_user_response.status_code) - self.assertEqual("", get_items_user_response.json()["content"]) + for user in InitUsers.users: + with self.subTest(i=user): + get_items_user_response = self.get_user_items(user, admintoken) + self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) + self.assertEqual("", get_items_user_response.json()["content"]) - """get user items with user token""" - def test_items_usertoken(self): - for k, v in dict.items(InitUsers.users): - token = self.login(k, v).json()["content"] - get_items_user_response = self.get_user_items(k, token) - self.assertEqual(200, get_items_user_response.status_code) + def test_get_items_by_user(self): + """get user items with user token""" + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + get_items_user_response = self.get_user_items(user, token) + self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertEqual("", get_items_user_response.json()["content"]) diff --git a/tests/functional/tests_get_user_item.py b/tests/functional/tests_get_user_item.py index acee498..ab13f1a 100644 --- a/tests/functional/tests_get_user_item.py +++ b/tests/functional/tests_get_user_item.py @@ -1,24 +1,25 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, DefaultUser +from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE class Test(ApiTestBase): - """get user item with admin token""" - def test_get_user_item_byadmin(self): + + def test_get_user_item_by_admin(self): + """get user item with admin token""" admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] - counter = 1 + counter = 0 for user in dict.keys(InitUsers.users): get_item_user_response = self.get_user_item(counter, user, admintoken) counter = counter + 1 - self.assertEqual(200, get_item_user_response.status_code) + self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertEqual("", get_item_user_response.json()["content"]) - """get user item with user token""" - def test_get_user_item_byuser(self): + def test_get_user_item_by_user(self): + """get user item with user token""" counter = 0 - for k, v in dict.items(InitUsers.users): - token = self.login(k, v).json()["content"] - get_item_user_response = self.get_user_item(counter, k, token) + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + get_item_user_response = self.get_user_item(counter, user, token) counter = counter + 1 - self.assertEqual(200, get_item_user_response.status_code) + self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertEqual("", get_item_user_response.json()["content"]) diff --git a/tests/functional/tests_update_item.py b/tests/functional/tests_update_item.py index a840f40..99e8355 100644 --- a/tests/functional/tests_update_item.py +++ b/tests/functional/tests_update_item.py @@ -1,23 +1,24 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers +from tests.constants.constants import InitUsers, VALID_STATUS_CODE class Test(ApiTestBase): - """test update item when users has no item""" + def test_update_empty_item(self): + """test update item when user has no item""" self.reset() - for user, password in dict.items(InitUsers.users): + for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] update_item_response = self.update_item(1, token, "Product") - self.assertEqual(200, update_item_response.status_code) + self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertFalse(update_item_response.json()["content"]) - """test update item when users have item""" def test_update_item(self): - for user, password in dict.items(InitUsers.users): + """test update item when user has item""" + for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] self.add_item(1, token, "Car") update_item_response = self.update_item(1, token, "Product") - self.assertEqual(200, update_item_response.status_code) + self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertTrue(update_item_response.json()["content"]) self.reset() From 885fd2d545d9b42ab3cb167d2d57a9f674bc536d Mon Sep 17 00:00:00 2001 From: asstelite Date: Mon, 29 Oct 2018 12:22:35 +0200 Subject: [PATCH 28/74] just saving work --- tests/functional/tests_locked.py | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index ed86b59..9190178 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -32,17 +32,25 @@ def test_locked(self): def test_not_locked(self): """User should not be locked""" passwords = ['', 'password', 'qwerty'] - users = list(InitUsers.users) - users.remove('admin') + users = InitUsers.users + users.pop('admin', None) for user in users: for password in passwords: self.login(user, password) kwargs = {'token': self.adminToken} + locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users = locked_users_request.json()['content'] + print(repr(locked_users)) logined_users_request = requests.get(generate_full_url(Endpoints.login_users), params=kwargs) logined_users = logined_users_request.json()['content'] - # print(repr(logined_users)) - self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tadmin\n4' - ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) + print(repr(logined_users)) + self.assertEqual(locked_users,'') + + + + # self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tadmin\n4' + # ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) + # comented because it work only in 1 of 5 attempts, because api randomly not login one of users sometimes def test_manual_lock(self): """Test functionality of locking users by manual command""" @@ -75,7 +83,6 @@ def test_reset_locked(self): """Test functionality of unlocking all users""" passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps users = list(InitUsers.users) - users.remove('admin') for user in users: for password in passwords: self.login(user, password) From 4cf5a78d215ccd72cfe4cb4ad9cd00e0524b2aa1 Mon Sep 17 00:00:00 2001 From: asstelite Date: Mon, 29 Oct 2018 13:34:49 +0200 Subject: [PATCH 29/74] just saving work --- tests/functional/__init__.py | 6 +++++ tests/functional/tests_locked.py | 39 +++++++++++++------------------- 2 files changed, 22 insertions(+), 23 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 532e035..56f72f5 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -14,3 +14,9 @@ def setUp(self): def login(self, name:str, password:str) -> object: return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) + + def get_locked_users(self, kwargs): + return self.request_session.get(generate_full_url(Endpoints.locked_users), params = kwargs) + + def get_logined_users(self, kwargs): + return self.request_session.get(generate_full_url(Endpoints.login_users), params = kwargs) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 9190178..7e6300d 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -13,6 +13,10 @@ def setUp(self): response = self.login(DefaultUser.user, DefaultUser.password) self.adminToken = response.json()['content'] + def tearDown(self): + """Reset api after each test""" + requests.get(generate_full_url(Endpoints.reset)) + def test_locked(self): """Test functionality of locking users""" passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps @@ -22,12 +26,12 @@ def test_locked(self): for password in passwords: self.login(user, password) kwargs = {'token': self.adminToken} - locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4' ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) - requests.get(generate_full_url(Endpoints.reset)) # reset api + def test_not_locked(self): """User should not be locked""" @@ -38,28 +42,17 @@ def test_not_locked(self): for password in passwords: self.login(user, password) kwargs = {'token': self.adminToken} - locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] - print(repr(locked_users)) - logined_users_request = requests.get(generate_full_url(Endpoints.login_users), params=kwargs) - logined_users = logined_users_request.json()['content'] - print(repr(logined_users)) self.assertEqual(locked_users,'') - - - # self.assertEqual(logined_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tadmin\n4' - # ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) - # comented because it work only in 1 of 5 attempts, because api randomly not login one of users sometimes - def test_manual_lock(self): """Test functionality of locking users by manual command""" users = list(InitUsers.users) users.remove('admin') kwargs = {'token': self.adminToken, 'name': users[1]} requests.post((generate_full_url(Endpoints.locked_user) + users[1]), params=kwargs) - locked_users_request1 = requests.get(generate_full_url(Endpoints.locked_users), - params={'token': self.adminToken}) + locked_users_request1 = self.get_locked_users(kwargs) locked_users = locked_users_request1.json()['content'] s = '0 \t' + users[1] + '\n' self.assertEqual(locked_users, s) @@ -69,15 +62,15 @@ def test_manual_unlock(self): users = list(InitUsers.users) users.remove('admin') passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps + user_to_lock = users[3] for password in passwords: - self.login(users[3], password) - kwargs = {'token': self.adminToken, 'name': users[3]} - requests.put((generate_full_url(Endpoints.locked_user) + users[3]), params=kwargs) - locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), - params={'token': self.adminToken}) + self.login(user_to_lock, password) + kwargs = {'token': self.adminToken, 'name': user_to_lock} + requests.put((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) + locked_users_request = self.get_locked_users(kwargs) # requests.get(generate_full_url(Endpoints.locked_users), + # params={'token': self.adminToken}) locked_users = locked_users_request.text - if users[3] in locked_users: - self.assertTrue(False) + self.assertNotIn(user_to_lock, locked_users) def test_reset_locked(self): """Test functionality of unlocking all users""" @@ -88,6 +81,6 @@ def test_reset_locked(self): self.login(user, password) kwargs = {'token': self.adminToken} requests.put(generate_full_url(Endpoints.locked_reset), params=kwargs) - locked_users_request = requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users_request = self.get_locked_users(kwargs) #requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') From 84a5af806a2aa4b77ba92d82f96fad210c2378f0 Mon Sep 17 00:00:00 2001 From: asstelite Date: Mon, 29 Oct 2018 13:36:02 +0200 Subject: [PATCH 30/74] just saving work --- tests/functional/tests_locked.py | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 7e6300d..977c581 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -67,8 +67,7 @@ def test_manual_unlock(self): self.login(user_to_lock, password) kwargs = {'token': self.adminToken, 'name': user_to_lock} requests.put((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) - locked_users_request = self.get_locked_users(kwargs) # requests.get(generate_full_url(Endpoints.locked_users), - # params={'token': self.adminToken}) + locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.text self.assertNotIn(user_to_lock, locked_users) @@ -81,6 +80,6 @@ def test_reset_locked(self): self.login(user, password) kwargs = {'token': self.adminToken} requests.put(generate_full_url(Endpoints.locked_reset), params=kwargs) - locked_users_request = self.get_locked_users(kwargs) #requests.get(generate_full_url(Endpoints.locked_users), params=kwargs) + locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') From d1475470fb13c18485be1d6021053b0737b1601a Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Mon, 29 Oct 2018 16:50:54 +0200 Subject: [PATCH 31/74] Refactoring tests --- tests/constants/constants.py | 9 ++- tests/functional/__init__.py | 16 +++--- tests/functional/tests_add_item.py | 30 +++++++++- tests/functional/tests_all_items.py | 47 +++++++++++----- tests/functional/tests_delete_item.py | 12 +++- tests/functional/tests_get_all_items_user.py | 31 ++++++++++ tests/functional/tests_get_item_by_index.py | 43 ++++++++++---- tests/functional/tests_get_itemindexes.py | 56 +++++++++++++------ tests/functional/tests_get_items_user.py | 23 -------- ...tem.py => tests_get_user_item_by_index.py} | 16 ++++-- tests/functional/tests_update_item.py | 41 ++++++++++---- 11 files changed, 229 insertions(+), 95 deletions(-) create mode 100644 tests/functional/tests_get_all_items_user.py delete mode 100644 tests/functional/tests_get_items_user.py rename tests/functional/{tests_get_user_item.py => tests_get_user_item_by_index.py} (67%) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index b8634a7..84a7967 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -10,7 +10,9 @@ class DefaultUser: class DefaultToken: token = "0123456789ABCDEF0123456789ABCDEF" - invalid_token = "2134rfvsd231g45" + + +INVALID_TOKEN = "2134rfvsd231g45" class DefaultItem: @@ -66,8 +68,9 @@ class Endpoints: locked_users = "/locked/users" locked_user = "/locked/user" locked_reset = "/locked/reset" - item_user = "/item/user/" - item = "/item" + item_user = "/item/user/{name}" + item_user_by_index = "/item/{index}/user/{name}" + item = "/item/{index}" items = "/items" itemindexes = "/itemindexes" diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 75c5bfd..455c33a 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -16,28 +16,28 @@ def reset(self): def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) - def get_user_items(self, user, admintoken): - return self.request_session.get("http://localhost:8080/item/user/{name}".format(name=user), + def get_user_all_items(self, user, admintoken): + return self.request_session.get(generate_full_url(Endpoints.item_user).format(name=user), params={"token": admintoken}) - def get_user_item(self, index, user, admintoken): - return self.request_session.get("http://localhost:8080/item/{index}/user/{name}".format(index=index, name=user), + def get_user_item_by_index(self, index, user, admintoken): + return self.request_session.get(generate_full_url(Endpoints.item_user_by_index).format(index=index, name=user), params={"token": admintoken}) def add_item(self, index, token, item): - return self.request_session.post("http://localhost:8080/item/{index}".format(index=index), + return self.request_session.post(generate_full_url(Endpoints.item).format(index=index), params={"token": token, "item": item}) def delete_item(self, index, token): - return self.request_session.delete("http://localhost:8080/item/{index}".format(index=index), + return self.request_session.delete(generate_full_url(Endpoints.item).format(index=index), params={"token": token}) def update_item(self, index, token, item): - return self.request_session.put("http://localhost:8080/item/{index}".format(index=index), + return self.request_session.put(generate_full_url(Endpoints.item).format(index=index), params={"token": token, "item": item}) def get_item(self, index, token): - return self.request_session.get("http://localhost:8080/item/{index}".format(index=index), + return self.request_session.get(generate_full_url(Endpoints.item).format(index=index), params={"token": token}) def get_itemindexes(self, token): diff --git a/tests/functional/tests_add_item.py b/tests/functional/tests_add_item.py index 728beab..80f9262 100644 --- a/tests/functional/tests_add_item.py +++ b/tests/functional/tests_add_item.py @@ -1,6 +1,6 @@ from tests.functional import ApiTestBase from random import choice, randint -from tests.constants.constants import InitUsers, DefaultToken, VALID_STATUS_CODE, ITEM_NAMES +from tests.constants.constants import InitUsers, INVALID_TOKEN, VALID_STATUS_CODE, ITEM_NAMES item_index = randint(0, 1000) @@ -9,6 +9,14 @@ class TestAddItem(ApiTestBase): + def setUp(self): + super().setUp() + self.reset() + + def tearDown(self): + super().tearDown() + self.reset() + def test_add_item_positive(self): """test with valid token""" counter = 0 @@ -19,11 +27,27 @@ def test_add_item_positive(self): counter = counter + 1 self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertTrue(add_item_user_response.json()["content"]) - self.reset() + + def test_add_specific_item(self): + """test add item with specific item""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + get_item_response = self.get_item(item_index, token) + self.assertEqual(item_name, get_item_response.json()["content"]) def test_add_item_negative(self): """test with invalid token""" - token = DefaultToken.invalid_token + token = INVALID_TOKEN add_item_user_response = self.add_item(item_index, token, item_name) self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertFalse(add_item_user_response.json()["content"]) + + def test_add_item_invalid_index(self): + """test add item when index not int""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + add_item_user_response = self.add_item(item_name, token, item_name) + self.assertNotEqual(VALID_STATUS_CODE, add_item_user_response.status_code) diff --git a/tests/functional/tests_all_items.py b/tests/functional/tests_all_items.py index 5d69273..69a20ea 100644 --- a/tests/functional/tests_all_items.py +++ b/tests/functional/tests_all_items.py @@ -1,26 +1,45 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, VALID_STATUS_CODE +from tests.constants.constants import InitUsers, INVALID_TOKEN, VALID_STATUS_CODE class TestAllItems(ApiTestBase): + def setUp(self): + super().setUp() + self.reset() + + def tearDown(self): + super().tearDown() + self.reset() + def test_without_items(self): """test when users have not any items""" - self.reset() for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - get_all_items_response = self.get_all_items(token) - self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) - self.assertFalse(get_all_items_response.json()["content"]) + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + get_all_items_response = self.get_all_items(token) + self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) + self.assertFalse(get_all_items_response.json()["content"]) def test_with_items(self): """test when users have items""" - self.reset() for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - self.add_item(1, token, "Product") - self.add_item(2, token, "Car") - get_all_items_response = self.get_all_items(token) - self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) - self.assertNotEqual("", get_all_items_response.json()["content"]) - self.reset() + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(1, token, "Product") + self.add_item(2, token, "Car") + get_all_items_response = self.get_all_items(token) + self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) + self.assertNotEqual("", get_all_items_response.json()["content"]) + self.assertTrue(get_all_items_response.json()["content"]) + + def test_items_by_invalid_token(self): + """test with invalid token""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(1, token, "Product") + self.add_item(2, token, "Car") + get_all_items_response = self.get_all_items(INVALID_TOKEN) + self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) + self.assertFalse(get_all_items_response.json()["content"]) diff --git a/tests/functional/tests_delete_item.py b/tests/functional/tests_delete_item.py index 9b284c5..5c1bce3 100644 --- a/tests/functional/tests_delete_item.py +++ b/tests/functional/tests_delete_item.py @@ -7,11 +7,18 @@ item_index = randint(0, 1000) -class Test(ApiTestBase): +class TestDeleteItem(ApiTestBase): + + def setUp(self): + super().setUp() + self.reset() + + def tearDown(self): + super().tearDown() + self.reset() def test_delete_empty_item(self): """delete when users have not any items""" - self.reset() for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] @@ -28,4 +35,3 @@ def test_delete_item(self): delete_item_response = self.delete_item(item_index, token) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) self.assertTrue(delete_item_response.json()["content"]) - self.reset() diff --git a/tests/functional/tests_get_all_items_user.py b/tests/functional/tests_get_all_items_user.py new file mode 100644 index 0000000..7c1c659 --- /dev/null +++ b/tests/functional/tests_get_all_items_user.py @@ -0,0 +1,31 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE + + +class TestAllUserItems(ApiTestBase): + + def setUp(self): + super().setUp() + self.reset() + + def tearDown(self): + super().tearDown() + self.reset() + + def test_get_items_by_admin(self): + """get user items with admintoken""" + admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + for user in InitUsers.users: + with self.subTest(i=user): + get_items_user_response = self.get_user_all_items(user, admintoken) + self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) + self.assertTrue(get_items_user_response.json()["content"]) + + def test_get_items_by_user(self): + """get user items with user token""" + for user in InitUsers.users: + with self.subTest(i=user): + token = self.login("kilinatc", "password").json()["content"] + get_items_user_response = self.get_user_all_items(user, token) + self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) + self.assertFalse(get_items_user_response.json()["content"]) diff --git a/tests/functional/tests_get_item_by_index.py b/tests/functional/tests_get_item_by_index.py index 7d2abb5..c15092c 100644 --- a/tests/functional/tests_get_item_by_index.py +++ b/tests/functional/tests_get_item_by_index.py @@ -1,26 +1,47 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, VALID_STATUS_CODE +from random import choice, randint +from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES -class Test(ApiTestBase): +item_index = randint(0, 1000) +item_name = choice(ITEM_NAMES) + + +class TestGetItemByIndex(ApiTestBase): + + def setUp(self): + super().setUp() + self.reset() + + def tearDown(self): + super().tearDown() + self.reset() def test_get_empty_item(self): """test when users have not items""" - self.reset() for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - get_item_response = self.get_item(1, token) + get_item_response = self.get_item(item_index, token) self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) self.assertFalse(get_item_response.json()["content"]) def test_get_item(self): """test when users have item""" for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - self.add_item(1, token, "Car") - get_item_response = self.get_item(1, token) - self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) - self.assertTrue(get_item_response.json()["content"]) - self.assertEqual("Car", get_item_response.json()["content"]) - self.reset() + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + get_item_response = self.get_item(item_index, token) + self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) + self.assertTrue(get_item_response.json()["content"]) + self.assertEqual(item_name, get_item_response.json()["content"]) + + def test_get_item_index_str(self): + """test get item with str index""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + get_item_response = self.get_item("call", token) + self.assertNotEqual(VALID_STATUS_CODE, get_item_response.status_code) diff --git a/tests/functional/tests_get_itemindexes.py b/tests/functional/tests_get_itemindexes.py index 3b7ab90..bb25cb2 100644 --- a/tests/functional/tests_get_itemindexes.py +++ b/tests/functional/tests_get_itemindexes.py @@ -1,23 +1,47 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, VALID_STATUS_CODE +from random import choice, randint +from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN -class Test(ApiTestBase): - def test_get_empty_itemindexes(self): +item_name = choice(ITEM_NAMES) +item_index = randint(0, 1000) + + +class TestGetItemIndexes(ApiTestBase): + + def setUp(self): + super().setUp() self.reset() - for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - get_itemindexes_response = self.get_itemindexes(token) - self.assertEqual(VALID_STATUS_CODE, get_itemindexes_response.status_code) - self.assertEqual("", get_itemindexes_response.json()["content"]) - def test_get_itemindexes(self): + def tearDown(self): + super().tearDown() self.reset() + + def test_get_empty_item_indexes(self): + """test when user have not item indexes""" for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - self.add_item(3, token, "Product") - get_itemindexes_response = self.get_itemindexes(token) - self.assertEqual(VALID_STATUS_CODE, get_itemindexes_response.status_code) - self.assertNotEqual("", get_itemindexes_response.json()["content"]) - self.assertEqual("3 ", get_itemindexes_response.json()["content"]) - self.reset() + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + get_item_indexes_response = self.get_itemindexes(token) + self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) + self.assertFalse(get_item_indexes_response.json()["content"]) + + def test_get_item_indexes(self): + """test get when user have any item""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + get_item_indexes_response = self.get_itemindexes(token) + self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) + self.assertTrue(get_item_indexes_response.json()["content"]) + + def test_get_item_indexes_by_invalid_token(self): + """test get item indexes with invalid token""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + get_item_indexes_response = self.get_itemindexes(INVALID_TOKEN) + self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) + self.assertFalse(get_item_indexes_response.json()["content"]) diff --git a/tests/functional/tests_get_items_user.py b/tests/functional/tests_get_items_user.py deleted file mode 100644 index cadece0..0000000 --- a/tests/functional/tests_get_items_user.py +++ /dev/null @@ -1,23 +0,0 @@ -from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE - - -class Test(ApiTestBase): - - def test_get_items_by_admin(self): - """get user items with admintoken""" - self.reset() - admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] - for user in InitUsers.users: - with self.subTest(i=user): - get_items_user_response = self.get_user_items(user, admintoken) - self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) - self.assertEqual("", get_items_user_response.json()["content"]) - - def test_get_items_by_user(self): - """get user items with user token""" - for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - get_items_user_response = self.get_user_items(user, token) - self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) - self.assertEqual("", get_items_user_response.json()["content"]) diff --git a/tests/functional/tests_get_user_item.py b/tests/functional/tests_get_user_item_by_index.py similarity index 67% rename from tests/functional/tests_get_user_item.py rename to tests/functional/tests_get_user_item_by_index.py index ab13f1a..70bc1b9 100644 --- a/tests/functional/tests_get_user_item.py +++ b/tests/functional/tests_get_user_item_by_index.py @@ -2,14 +2,22 @@ from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE -class Test(ApiTestBase): +class TestUserItemByIndex(ApiTestBase): + + def setUp(self): + super().setUp() + self.reset() + + def tearDown(self): + super().tearDown() + self.reset() def test_get_user_item_by_admin(self): """get user item with admin token""" admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] counter = 0 for user in dict.keys(InitUsers.users): - get_item_user_response = self.get_user_item(counter, user, admintoken) + get_item_user_response = self.get_user_item_by_index(counter, user, admintoken) counter = counter + 1 self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertEqual("", get_item_user_response.json()["content"]) @@ -19,7 +27,7 @@ def test_get_user_item_by_user(self): counter = 0 for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] - get_item_user_response = self.get_user_item(counter, user, token) + get_item_user_response = self.get_user_item_by_index(counter, user, token) counter = counter + 1 self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) - self.assertEqual("", get_item_user_response.json()["content"]) + self.assertFalse(get_item_user_response.json()["content"]) diff --git a/tests/functional/tests_update_item.py b/tests/functional/tests_update_item.py index 99e8355..06b520a 100644 --- a/tests/functional/tests_update_item.py +++ b/tests/functional/tests_update_item.py @@ -1,24 +1,45 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, VALID_STATUS_CODE +from random import choice, randint +from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES -class Test(ApiTestBase): +item_index = randint(0, 1000) +item_name = choice(ITEM_NAMES) + + +class TestUpdateItem(ApiTestBase): + + def setUp(self): + super().setUp() + self.reset() + + def tearDown(self): + super().tearDown() + self.reset() def test_update_empty_item(self): """test update item when user has no item""" - self.reset() for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - update_item_response = self.update_item(1, token, "Product") - self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) - self.assertFalse(update_item_response.json()["content"]) + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + update_item_response = self.update_item(item_index, token, item_name) + self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) + self.assertFalse(update_item_response.json()["content"]) def test_update_item(self): """test update item when user has item""" for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] - self.add_item(1, token, "Car") - update_item_response = self.update_item(1, token, "Product") + self.add_item(item_index, token, item_name) + update_item_response = self.update_item(item_index, token, item_name) self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertTrue(update_item_response.json()["content"]) - self.reset() + + def test_update_item_invalid_index(self): + """test update item when index not int""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + update_item_response = self.update_item(item_name, token, item_name) + self.assertNotEqual(VALID_STATUS_CODE, update_item_response.status_code) From af697a5e6bf3d9f2badf1047f05ad8ef3fb596ef Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Mon, 29 Oct 2018 17:25:21 +0200 Subject: [PATCH 32/74] Change file tests_get_all_items_user, and file Constants(removed admin from users) --- tests/constants/constants.py | 3 +-- tests/functional/tests_get_all_items_user.py | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index 84a7967..8d0c823 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -35,8 +35,7 @@ class DefaultBool: class InitUsers: - users = {"admin": "qwerty", - "akimatc": "qwerty", + users = {"akimatc": "qwerty", "khalaktc": "qwerty", "kilinatc": "qwerty", "OKonokhtc": "qwerty", diff --git a/tests/functional/tests_get_all_items_user.py b/tests/functional/tests_get_all_items_user.py index 7c1c659..6ff1a58 100644 --- a/tests/functional/tests_get_all_items_user.py +++ b/tests/functional/tests_get_all_items_user.py @@ -19,7 +19,7 @@ def test_get_items_by_admin(self): with self.subTest(i=user): get_items_user_response = self.get_user_all_items(user, admintoken) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) - self.assertTrue(get_items_user_response.json()["content"]) + self.assertFalse(get_items_user_response.json()["content"]) def test_get_items_by_user(self): """get user items with user token""" From 422e243f6fca1dc91be4d6b84c399146bf4ef375 Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Mon, 29 Oct 2018 18:37:27 +0200 Subject: [PATCH 33/74] Some changes in the tests files --- tests/functional/tests_get_all_items_user.py | 40 ++++++++++++++++++- .../tests_get_user_item_by_index.py | 22 +++++++--- 2 files changed, 55 insertions(+), 7 deletions(-) diff --git a/tests/functional/tests_get_all_items_user.py b/tests/functional/tests_get_all_items_user.py index 6ff1a58..94e251e 100644 --- a/tests/functional/tests_get_all_items_user.py +++ b/tests/functional/tests_get_all_items_user.py @@ -1,5 +1,10 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE +from random import choice, randint +from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN + + +item_index = randint(0, 1000) +item_name = choice(ITEM_NAMES) class TestAllUserItems(ApiTestBase): @@ -21,6 +26,27 @@ def test_get_items_by_admin(self): self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) + def test_get_items_by_admin_with_invalid_token(self): + """get items by admin with invalid token""" + self.login(DefaultUser.user, DefaultUser.password) + for user in InitUsers.users: + with self.subTest(i=user): + get_items_user_response = self.get_user_all_items(user, INVALID_TOKEN) + self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) + self.assertFalse(get_items_user_response.json()["content"]) + + def test_get_added_items_by_admin(self): + """get added user items by admin""" + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + for user in InitUsers.users: + with self.subTest(i=user): + get_items_user_response = self.get_user_all_items(user, admintoken) + self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) + self.assertTrue(get_items_user_response.json()["content"]) + def test_get_items_by_user(self): """get user items with user token""" for user in InitUsers.users: @@ -29,3 +55,15 @@ def test_get_items_by_user(self): get_items_user_response = self.get_user_all_items(user, token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) + + def test_get_added_items_by_user(self): + """get added user items by user""" + for user, password in InitUsers.users.items(): + token = self.login(user, password).json()["content"] + self.add_item(item_index, token, item_name) + admintoken = self.login("akinatc", "password").json()["content"] + for user in InitUsers.users: + with self.subTest(i=user): + get_items_user_response = self.get_user_all_items(user, admintoken) + self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) + self.assertFalse(get_items_user_response.json()["content"]) diff --git a/tests/functional/tests_get_user_item_by_index.py b/tests/functional/tests_get_user_item_by_index.py index 70bc1b9..d68b289 100644 --- a/tests/functional/tests_get_user_item_by_index.py +++ b/tests/functional/tests_get_user_item_by_index.py @@ -1,5 +1,9 @@ from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE +from random import randint +from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE, INVALID_TOKEN + + +item_index = randint(0, 1000) class TestUserItemByIndex(ApiTestBase): @@ -14,13 +18,11 @@ def tearDown(self): def test_get_user_item_by_admin(self): """get user item with admin token""" - admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] - counter = 0 for user in dict.keys(InitUsers.users): - get_item_user_response = self.get_user_item_by_index(counter, user, admintoken) - counter = counter + 1 + admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + get_item_user_response = self.get_user_item_by_index(item_index, user, admintoken) self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) - self.assertEqual("", get_item_user_response.json()["content"]) + self.assertFalse(get_item_user_response.json()["content"]) def test_get_user_item_by_user(self): """get user item with user token""" @@ -31,3 +33,11 @@ def test_get_user_item_by_user(self): counter = counter + 1 self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertFalse(get_item_user_response.json()["content"]) + + def test_get_user_item_by_invalid_token(self): + """get user item with invalid token""" + for user in dict.keys(InitUsers.users): + self.login(DefaultUser.user, DefaultUser.password) + get_item_user_response = self.get_user_item_by_index(item_index, user, INVALID_TOKEN) + self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) + self.assertFalse(get_item_user_response.json()["content"]) From 78232e5bdaa551fca626ba45fadb5c3d549d7af1 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Mon, 29 Oct 2018 21:17:42 +0200 Subject: [PATCH 34/74] added new user tests, edited init file --- tests/functional/__init__.py | 16 ++ tests/functional/test_user_change_pass.py | 0 ...test_user_change_pass_with_invalid_data.py | 31 --- tests/functional/test_user_create_new.py | 23 -- .../test_user_create_new_with_invalid_name.py | 21 -- .../test_user_create_new_with_invalid_pass.py | 21 -- tests/functional/test_user_get_name.py | 23 -- tests/functional/test_user_remove.py | 4 +- tests/functional/tests_user_change_pass.py | 191 ++++++++++++++ tests/functional/tests_user_create_new.py | 246 ++++++++++++++++++ 10 files changed, 454 insertions(+), 122 deletions(-) delete mode 100644 tests/functional/test_user_change_pass.py delete mode 100644 tests/functional/test_user_change_pass_with_invalid_data.py delete mode 100644 tests/functional/test_user_create_new.py delete mode 100644 tests/functional/test_user_create_new_with_invalid_name.py delete mode 100644 tests/functional/test_user_create_new_with_invalid_pass.py delete mode 100644 tests/functional/test_user_get_name.py create mode 100644 tests/functional/tests_user_change_pass.py create mode 100644 tests/functional/tests_user_create_new.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 012cf0b..6582313 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -12,3 +12,19 @@ def setUp(self): def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) + + def logout(self, name: str, token: str): + return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) + + def create_new_user(self, adminToken, newName, newPassword, adminRights): + return self.request_session.post(generate_full_url(Endpoints.user), + {"token": adminToken, "name": newName, "password": newPassword, + "rights": adminRights}) + + def change_pass(self, token, oldpassword, newpassword): + return self.request_session.put(generate_full_url(Endpoints.user), {"token": token, "oldpassword": oldpassword, + "newpassword": newpassword}) + + def tearDown(self): + return self.request_session.get(generate_full_url(Endpoints.reset)) + diff --git a/tests/functional/test_user_change_pass.py b/tests/functional/test_user_change_pass.py deleted file mode 100644 index e69de29..0000000 diff --git a/tests/functional/test_user_change_pass_with_invalid_data.py b/tests/functional/test_user_change_pass_with_invalid_data.py deleted file mode 100644 index 5deb8a0..0000000 --- a/tests/functional/test_user_change_pass_with_invalid_data.py +++ /dev/null @@ -1,31 +0,0 @@ -import requests - -from tests.constants.constants import Endpoints, DefaultUser -from tests.functional import ApiTestBase -from tests.utils.helper import generate_full_url - - -class TestChangePass(ApiTestBase): - def setUp(self): - """get admin token""" - super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] - - def test_add_User_with_valid_data(self): - # create user - - user = requests.post(generate_full_url(Endpoints.user), - params={'token': self.adminToken, "name": "testusero", "password": "qwertyqq", - "rights": "false"}) - - # login with new user - login_with_new_user = requests.post(generate_full_url(Endpoints.login), - params={"name": "testusero", "password": "qwertyqq"}) - token = login_with_new_user.json()['content'] - - # change pass with invalid spaces - change_pass = requests.put(generate_full_url(Endpoints.user), - params={"token": token, "oldpassword": "qwertyqq", "newpassword": "qwerto "}) - self.assertNotIn("true", change_pass.text, "error, pass was changed, and have spaces") - diff --git a/tests/functional/test_user_create_new.py b/tests/functional/test_user_create_new.py deleted file mode 100644 index e1b2500..0000000 --- a/tests/functional/test_user_create_new.py +++ /dev/null @@ -1,23 +0,0 @@ -import requests - -from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser -from tests.utils.helper import generate_full_url - - -class TestCreateNewUser(ApiTestBase): - - def setUp(self): - """Return admin token""" - super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] - - def test_add_User_with_valid_data(self): - - """login and get admin token""" - - create_user = requests.post(generate_full_url(Endpoints.user), - params={'token': self.adminToken, "name": "validtest", - "password": "qwertyqq", "rights": "true"}) - self.assertIn("true", create_user.text) diff --git a/tests/functional/test_user_create_new_with_invalid_name.py b/tests/functional/test_user_create_new_with_invalid_name.py deleted file mode 100644 index 4a0c73d..0000000 --- a/tests/functional/test_user_create_new_with_invalid_name.py +++ /dev/null @@ -1,21 +0,0 @@ -import requests - -from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser -from tests.utils.helper import generate_full_url - - -class TestCreateNewUserWithInvalidName(ApiTestBase): - - def setUp(self): - """Return admin token""" - super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] - - def test_create_User_with_invalid_username(self): - """creating user with spaces""" - create_user_vith_invalid_pass = requests.post(generate_full_url(Endpoints.user), - params={'token': self.adminToken, "name": "invalidtestname ", - "password": "test ", "rights": "false"}) - self.assertNotIn('true', create_user_vith_invalid_pass.text, "error, username have spaces") diff --git a/tests/functional/test_user_create_new_with_invalid_pass.py b/tests/functional/test_user_create_new_with_invalid_pass.py deleted file mode 100644 index c03bf8f..0000000 --- a/tests/functional/test_user_create_new_with_invalid_pass.py +++ /dev/null @@ -1,21 +0,0 @@ -import requests - -from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser -from tests.utils.helper import generate_full_url - - -class TestCreateNewUserWithInvalidPass(ApiTestBase): - - def setUp(self): - """Return admin token""" - super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] - - def test_create_User_with_invalid_pass(self): - """creating user with spaces""" - create_user_vith_invalid_pass = requests.post(generate_full_url(Endpoints.user), - params={'token': self.adminToken, "name": "invalidtestpass", - "password": "test ", "rights": "false"}) - self.assertNotIn('true', create_user_vith_invalid_pass.text, "error, pass have spaces") diff --git a/tests/functional/test_user_get_name.py b/tests/functional/test_user_get_name.py deleted file mode 100644 index 871bfa5..0000000 --- a/tests/functional/test_user_get_name.py +++ /dev/null @@ -1,23 +0,0 @@ - -import requests - -from tests.constants.constants import DefaultUser, Endpoints -from tests.functional import ApiTestBase -from tests.utils.helper import generate_full_url - - -class TestGetUserName(ApiTestBase): - - def test_get_user_name(self): - - """login with admin""" - - response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] - -#get logged user name - - get_name = requests.get(generate_full_url(Endpoints.user), params={'token': self.adminToken}) - logged_user_name = get_name.json()['content'] - self.assertIn(DefaultUser.user, logged_user_name) - diff --git a/tests/functional/test_user_remove.py b/tests/functional/test_user_remove.py index acd20bd..ebab3ae 100644 --- a/tests/functional/test_user_remove.py +++ b/tests/functional/test_user_remove.py @@ -16,14 +16,12 @@ def test_remove_User_with_valid_data(self): # create test_user creating = requests.post(generate_full_url(Endpoints.user), params={'token': self.adminToken, "name": "testuserdelete", "password": "qwerty", "rights": "false"}) - print (creating.json()) #delete test user remove_created_user = requests.delete(generate_full_url(Endpoints.user), params={'token': self.adminToken, "name": "testuserdelete"}) - print(remove_created_user.json()) self.assertIn("true", remove_created_user.text) - try to login with deleted user + def test_login_deleted_user(self): deleted_user_login = requests.post(generate_full_url(Endpoints.login), params = {"name": "testuserdelete", "password": "qwerty"}) diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py new file mode 100644 index 0000000..4e0fd12 --- /dev/null +++ b/tests/functional/tests_user_change_pass.py @@ -0,0 +1,191 @@ +from tests.functional import ApiTestBase + + +class TestChangePass(ApiTestBase): + + def test_User_change_pass_valid_data(self): + """login with exist user and change pass""" + + login = self.login("vbudktc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # change pass + change_pass = self.change_pass(userToken, "qwerty", "qwerty") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "change pass error") + + # login with changed pass + login_with_new_pass = self.login("vbudktc", "qwerty") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertEqual(32, len_token, "login with changed pass error") + self.tearDown() + + def test_add_space_to_the_new_pass(self): + """add 1 space to the new pass""" + + login = self.login("vbudktc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # change pass + change_pass = self.change_pass(userToken, "qwerty", "qwerty ") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "change pass error") + + # login with changed pass + login_with_new_pass = self.login("vbudktc", "qwerty ") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass contain space!") + self.tearDown() + + def test_pass_contain_spaces_only(self): + """use spaces only for new pass""" + + login = self.login("vbudktc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # change pass + change_pass = self.change_pass(userToken, "qwerty", " ") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "change pass error") + + # login with changed pass + login_with_new_pass = self.login("vbudktc", " ") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Password created from spaces") + self.tearDown() + + def test_leave_pass_without_data(self): + """don't enter any data to the new pass""" + + login = self.login("vvasylystc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # leave pass without any data + change_pass = self.change_pass(userToken, "qwerty", "") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "pass") + + # login with changed pass + login_with_new_pass = self.login("vvasylystc", "") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field is empty") + self.tearDown() + + def test_enter_symbols(self): + """enter "!@#$%^&*()><" to the new pass""" + + login = self.login("vvasylystc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # leave pass without any data + change_pass = self.change_pass(userToken, "qwerty", "!@#$%^&*()><") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "pass") + + # login with changed pass + login_with_new_pass = self.login("vvasylystc", "!@#$%^&*()><") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain !@#$%^&*()") + self.tearDown() + + def test_use_cyrillic_letters(self): + """use cyrillic letters in new pass""" + + login = self.login("vvasylystc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # leave pass without any data + change_pass = self.change_pass(userToken, "qwerty", "ыва") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "pass") + + # login with changed pass + login_with_new_pass = self.login("vvasylystc", "ыва") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain cyrillic letters " + "= ыва") + self.tearDown() + + def test_use_ASCII_symbols(self): + """use_ASCII_symbols in new pass""" + + login = self.login("vvasylystc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # leave pass without any data + change_pass = self.change_pass(userToken, "qwerty", "Æð") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "pass") + + # login with changed pass + login_with_new_pass = self.login("vvasylystc", "Æð") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain ASCII symbols " + "Æð") + self.tearDown() + + def test_use_Japan_language(self): + + """use japan world in new pass""" + + login = self.login("vvasylystc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # leave pass without any data + change_pass = self.change_pass(userToken, "qwerty", "本") + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "pass") + + # login with changed pass + login_with_new_pass = self.login("vvasylystc", "本") + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain japan world " + "本") + self.tearDown() + + def test_use_very_long_pass(self): + """use very long new pass""" + + login = self.login("vvasylystc", "qwerty") + userToken = login.json()['content'] + self.assertEqual(200, login.status_code, "login error") + + # leave pass without any data + change_pass = self.change_pass(userToken, "qwerty", "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + ) + + self.assertIn("true", change_pass.text) + self.assertEqual(200, change_pass.status_code, "pass") + + # login with changed pass + login_with_new_pass = self.login("vvasylystc", "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + ) + + len_token = len(login.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") + self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field is too long, contain 410 " + "digits") + + self.tearDown() diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py new file mode 100644 index 0000000..bd90679 --- /dev/null +++ b/tests/functional/tests_user_create_new.py @@ -0,0 +1,246 @@ +from tests.functional import ApiTestBase +from tests.constants.constants import DefaultUser + + +class TestCreateNewUser(ApiTestBase): + + def setUp(self): + + """login admin and get admin token""" + + super().setUp() + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + def test_create_new_user(self): + + """create new user with valid data""" + + create_new_user = self.create_new_user(self.adminToken, "Username", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertEqual(32, len_of_new_user_token) + self.tearDown() + + def test_create_user_with_non_admin_token(self): + + """create new user with usage of non admin token""" + + login = self.login("slototc", "qwerty") + token = login.json()['content'] + create_new_user = self.create_new_user(token, "Username", "Pass", "false") + self.assertIn("false", create_new_user.text, "ERROR, user was created with user token") + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "Pass") + text_of_login_message = str(login.content) + self.assertIn("ERROR", text_of_login_message, "ERROR, user was created with user token") + self.tearDown() + + def test_give_invalid_admin_rights(self): + + """create new user with invalid admin rights""" + + create_new_user = self.create_new_user(self.adminToken, "Username", "Pass", "admin") + self.assertIn("Bad Request", create_new_user.text, "ERROR, user was created with invalid admin rights") + self.assertEquals(400, create_new_user.status_code) + self.assertNotEqual(200, create_new_user.status_code) + login = self.login("Username", "Pass") + text_of_login_message = str(login.content) + self.assertIn("ERROR", text_of_login_message, "ERROR, user was created with invalid admin rights") + self.tearDown() + + def test_create_user_add_spaces_to_login(self): + + """create new user with spaces on login""" + + create_new_user = self.create_new_user(self.adminToken, "Username ", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username ", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR, user was created with spaces in login!") + self.tearDown() + + def test_login_contain_only_spaces(self): + + """create new user with only spaces on login""" + + create_new_user = self.create_new_user(self.adminToken, " ", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login(" ", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR, user was created with spaces only in login!") + self.tearDown() + + def test_login_is_empty(self): + + """create new user with empty login """ + + create_new_user = self.create_new_user(self.adminToken, "", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with empty login!") + self.tearDown() + + def test_login_contain_symbols(self): + + """Login contain !@#$%^&*()<> """ + + create_new_user = self.create_new_user(self.adminToken, "!@#$%^&*()<>", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("!@#$%^&*()<>", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with !@#$%^&*()<> in login!") + self.tearDown() + + def test_login_contain_cyrillic_letters(self): + + """Login contain cyrillic letters""" + + create_new_user = self.create_new_user(self.adminToken, "ыва", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("ыва", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with cyrillic letters in login") + self.tearDown() + + def test_login_contain_ASCII_symbols(self): + + """Login contain ASCII symbols""" + + create_new_user = self.create_new_user(self.adminToken, "ø¶", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("ø¶", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. New user was created with ASCII symbols in login") + self.tearDown() + + def test_login_contain_Japan_symbols(self): + + """Login contain Japan symbols""" + + create_new_user = self.create_new_user(self.adminToken, "本本本本本", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("本本本本本", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with Japan symbols in login") + self.tearDown() + + def test_login_is_too_long(self): + + """Login is too long""" + + create_new_user = self.create_new_user(self.adminToken, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "aaaaaaaaaaaaaaaaaaaaa", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long login") + self.tearDown() + + def test_pass_contain_spaces(self): + + """Pass contain spaces""" + + create_new_user = self.create_new_user(self.adminToken, "Username", "Pass ", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "Pass ") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with spaces in password") + self.tearDown() + + def test_pass_contain_only_spaces(self): + + """Pass contain spaces only""" + + create_new_user = self.create_new_user(self.adminToken, "Username", " ", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", " ") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with spaces only in password!") + self.tearDown() + + def test_pass_is_empty(self): + + """create new user with empty pass""" + + create_new_user = self.create_new_user(self.adminToken, "Username", "", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with empty pass!") + self.tearDown() + + def test_pass_contain_symbols(self): + + """Pass contain !@#$%^&*()<> """ + + create_new_user = self.create_new_user(self.adminToken, "Username", "!@#$%^&*()<>", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "!@#$%^&*()<>") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with !@#$%^&*()<> in password") + self.tearDown() + + def test_pass_contain_cyrillic_letters(self): + + """Pass contain cyrillic letters""" + + create_new_user = self.create_new_user(self.adminToken, "Username", "ыва", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "ыва") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with cyrillic letters in password") + self.tearDown() + + def test_pass_contain_ASCII_symbols(self): + + """Login contain ASCII symbols""" + + create_new_user = self.create_new_user(self.adminToken, "Username", "ø¶", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "ø¶") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. New user was created with ASCII symbols in password") + self.tearDown() + + def test_pass_contain_Japan_symbols(self): + + """pass contain Japan symbols""" + + create_new_user = self.create_new_user(self.adminToken, "Username", "本本本本本", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Username", "本本本本本") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with Japan symbols in pass") + self.tearDown() + + def test_pass_is_too_long(self): + + """Password is too long""" + + create_new_user = self.create_new_user(self.adminToken, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "aaaaaaaaaaaaaaaaaaaaa", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long password") + self.tearDown() \ No newline at end of file From c6011b7cbbdc94d1382886c2861b83153961140d Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Mon, 29 Oct 2018 21:20:53 +0200 Subject: [PATCH 35/74] refactoring code pylint and pycodestyle fixes --- tests/constants/constants.py | 30 +++--- tests/functional/__init__.py | 42 +++++++- tests/functional/tests_admins.py | 54 ++++------- tests/functional/tests_login.py | 162 +++++++++++++------------------ tests/functional/tests_logout.py | 82 ++++++++-------- tests/utils/helper.py | 3 + 6 files changed, 192 insertions(+), 181 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index d224317..433a6b1 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -1,34 +1,42 @@ -# Default constants +"""Default constants""" class DefaultUser: - + """Default user with admin rights. Has admin token""" user = "admin" password = "qwerty" -class DefaultToken: +class Users: + """Default valid user, password and fake user, password""" + valid_user = "vvasylystc" + valid_password = "qwerty" + fake_user = "vVASYLystc333" + fake_password = "Qwerty123" + +class DefaultToken: + """Default token""" token = "0123456789ABCDEF0123456789ABCDEF" class DefaultItem: - + """Default item for items""" item = "empty" class DefaultNum: - + """Default number for items""" num = 1000 class DefaultBool: - + """Default bool for items""" bool = False class InitUsers: - + """The dictionary of all valid users""" users = {"admin": "qwerty", "akimatc": "qwerty", "khalaktc": "qwerty", @@ -41,7 +49,7 @@ class InitUsers: class InitInvalidUsers: - + """The dictionary with fake users""" invalid_users = {"admin": "QWERTY", "akimatc1": "qwerty", "khalaktc": "", @@ -50,17 +58,17 @@ class InitInvalidUsers: class BaseUrl: - + """Url for connecting to API""" base_url = "http://localhost:8080" class InvalidUrl: - + """Invalid url for testing exceptions""" invalid_url = "http://localhost:80801" class Endpoints: - + """All endpoints in API""" reset = "/reset" login = "/login" logout = "/logout" diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 0e3cc95..954637a 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -1,3 +1,5 @@ +"""Base class and functions for testing""" + import unittest import requests @@ -8,16 +10,52 @@ class ApiTestBase(unittest.TestCase): + """Main class for testing""" def setUp(self): + """Define open request session that will be executed before each test method.""" self.request_session = requests.session() def login(self, name: str, password: str) -> request: - return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) + """Login user with name and password.""" + return self.request_session.post(generate_full_url(Endpoints.login), + params={"name": name, "password": password}) def logout(self, name: str, token: str) -> request: - return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) + """Logout user with name and user token.""" + return self.request_session.post(generate_full_url(Endpoints.logout), + params={"name": name, "token": token}) + + def login_admins(self, token: str) -> request: + """Logged admins""" + return self.request_session.get(generate_full_url(Endpoints.login_admins), + params={"token": token}) + + def login_users(self, token: str) -> request: + """Logged users""" + return self.request_session.get(generate_full_url(Endpoints.login_users), + params={"token": token}) + + def login_tockens(self, token: str) -> request: + """Alive tokens""" + return self.request_session.get(generate_full_url(Endpoints.login_tockens), + params={"token": token}) + + def admins(self, token: str) -> request: + """All admins""" + return self.request_session.get(generate_full_url(Endpoints.admins), + params={"token": token}) def tearDown(self): + """Define close request session and reset API data + that will be executed after each test method.""" self.request_session.get(generate_full_url(Endpoints.reset)) self.request_session.close() + + +class Ascertains(unittest.TestCase): + """Class for ascertains""" + + def check_status_code_200(self, status_code: int): + """Check if response status code is valid""" + self.assertEqual(status_code, 200, "Error response status code (expected 200)") diff --git a/tests/functional/tests_admins.py b/tests/functional/tests_admins.py index 94545b4..06dcc61 100644 --- a/tests/functional/tests_admins.py +++ b/tests/functional/tests_admins.py @@ -1,48 +1,30 @@ -""" -Functional tests for admins -""" +"""Functional tests for admins""" -from tests.constants.constants import DefaultUser, Endpoints -from tests.functional import ApiTestBase -from tests.utils.helper import generate_full_url +from tests.constants.constants import Users, DefaultUser, DefaultToken +from tests.functional import ApiTestBase, Ascertains -class TestAdmins(ApiTestBase): - - def check_status_code_200(self, status_code: int): - self.assertEqual(status_code, 200, "Error response status code (expected 200)") +class TestAdmins(ApiTestBase, Ascertains): + """Class for testing""" def test_admins(self): - """Get all admins with admin token. If list not empty test pass""" + """Get all admins with admin token. If list not empty test pass.""" login = self.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - all_admins = self.request_session.get(generate_full_url(Endpoints.admins), params=token) + all_admins = self.admins(login.json().get("content")) self.check_status_code_200(all_admins.status_code) - # print(all_admins.text) self.assertTrue(all_admins.json().get("content"), "Content is empty") - def test_admins_users(self): + def test_admins_user(self): """Get all admins without admin token. If list empty test pass""" - for user, password in users.items(): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - all_admins = self.request_session.get(generate_full_url(Endpoints.admins), params=token) - self.check_status_code_200(all_admins.status_code) - # print(all_admins.text) - self.assertFalse(all_admins.json().get("content"), "Content is not empty") - + login = self.login(Users.valid_user, Users.valid_password) + self.check_status_code_200(login.status_code) + all_admins = self.admins(login.json().get("content")) + self.check_status_code_200(all_admins.status_code) + self.assertFalse(all_admins.json().get("content"), "Content is not empty") -users = {"akimatc": "qwerty", - "khalaktc": "qwerty", - "kilinatc": "qwerty", - "OKonokhtc": "qwerty", - "otlumtc": "qwerty", - "slototc": "qwerty", - "vbudktc": "qwerty", - "vvasylystc": "qwerty"} + def test_admins_default_token(self): + """Get all admins with default token. If list empty test pass""" + all_admins = self.admins(DefaultToken.token) + self.check_status_code_200(all_admins.status_code) + self.assertFalse(all_admins.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py index 54d1319..26197f3 100644 --- a/tests/functional/tests_login.py +++ b/tests/functional/tests_login.py @@ -1,123 +1,101 @@ -""" -Functional tests for logging users -""" +"""Functional tests for logging users""" -from tests.constants.constants import DefaultUser, InitUsers, InitInvalidUsers, Endpoints -from tests.functional import ApiTestBase -from tests.utils.helper import generate_full_url +from tests.constants.constants import DefaultUser, Users, DefaultToken +from tests.functional import ApiTestBase, Ascertains -class TestLogin(ApiTestBase): - - def check_status_code_200(self, status_code: int): - self.assertEqual(status_code, 200, "Error response status code (expected 200)") +class TestLogin(ApiTestBase, Ascertains): + """Class for testing""" def test_login(self): - """Logging users. If user got token test pass""" - for user, password in InitUsers.users.items(): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - self.assertEqual(len(login.json().get("content")), 32, "Invalid token") + """Login user. If user got token test pass.""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + self.assertEqual(len(login.json().get("content")), 32, "Invalid token") def test_login_user_not_found(self): - """Logging fake users. If user not found test pass""" - for user, password in InitInvalidUsers.invalid_users.items(): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - self.assertIn("ERROR, user not found", login.text, "User founded") + """Login fake user name. If user not found test pass.""" + login = self.login(Users.fake_user, Users.fake_password) + self.check_status_code_200(login.status_code) + self.assertIn("ERROR, user not found", login.text, "User founded") def test_login_user_locked(self): - """Logging 3 times invalid user to lock user. If user locked test pass""" - for user, password in InitInvalidUsers.invalid_users.items(): - for i in range(4): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - self.assertIn("ERROR, user locked", login.text, "User not locked") + """Login 4 times with fake password to lock. If user locked test pass.""" + for _ in range(4): + login = self.login(Users.valid_user, Users.fake_password) + self.check_status_code_200(login.status_code) + self.assertIn("ERROR, user locked", login.text, "User not locked") + + def test_login_fake_user_locked(self): + """Login 4 times with fake user to lock. If user not found test pass.""" + for _ in range(4): + login = self.login(Users.fake_user, Users.fake_password) + self.check_status_code_200(login.status_code) + self.assertIn("ERROR, user not found", login.text, "User locked") def test_login_admins(self): - """Get logged admins with admin token. If user had admin rights and got the list of logged admins test pass""" + """Get logged admins with admin token. + If user had admin rights and got the list of logged admins test pass.""" login = self.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - logged_admins = self.request_session.get(generate_full_url(Endpoints.login_admins), params=token) + logged_admins = self.login_admins(login.json().get("content")) self.check_status_code_200(logged_admins.status_code) - # print(logged_admins.text) self.assertTrue(logged_admins.json().get("content"), "Content is empty") - def test_login_admins_users(self): - """Get logged admins without admin token. If empty response test pass""" - for user, password in users.items(): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - logged_admins = self.request_session.get(generate_full_url(Endpoints.login_admins), params=token) - self.check_status_code_200(logged_admins.status_code) - # print(logged_admins.text) - self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + def test_login_admins_user(self): + """Get logged admins without admin token. If empty response test pass.""" + login = self.login(Users.valid_user, Users.valid_password) + self.check_status_code_200(login.status_code) + logged_admins = self.login_admins(login.json().get("content")) + self.check_status_code_200(logged_admins.status_code) + self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + + def test_login_admins_default_token(self): + """Get logged admins with default token. If empty response test pass.""" + logged_admins = self.login_admins(DefaultToken.token) + self.check_status_code_200(logged_admins.status_code) + self.assertFalse(logged_admins.json().get("content"), "Content is not empty") def test_login_users_admin(self): - """Get logged users with admin token. If got the list of logged users test pass""" + """Get logged users with admin token. If got the list of logged users test pass.""" login = self.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - logged_admins = self.request_session.get(generate_full_url(Endpoints.login_users), params=token) + logged_admins = self.login_users(login.json().get("content")) self.check_status_code_200(logged_admins.status_code) - # print(logged_admins.text) self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_users(self): - """Get logged users without admin token. If list of users empty test pass""" - for user, password in users.items(): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - logged_admins = self.request_session.get(generate_full_url(Endpoints.login_users), params=token) - self.check_status_code_200(logged_admins.status_code) - # print(logged_admins.text) - self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + """Get logged users without admin token. If list of users empty test pass.""" + login = self.login(Users.valid_user, Users.valid_password) + self.check_status_code_200(login.status_code) + logged_users = self.login_users(login.json().get("content")) + self.check_status_code_200(logged_users.status_code) + self.assertFalse(logged_users.json().get("content"), "Content is not empty") + + def test_login_users_default_token(self): + """Get logged users without admin token. If list of users empty test pass.""" + logged_users = self.login_users(DefaultToken.token) + self.check_status_code_200(logged_users.status_code) + self.assertFalse(logged_users.json().get("content"), "Content is not empty") def test_login_tockens_admin(self): - """Get alive tockens with admin token. If got list of tokens test pass""" + """Get alive tockens with admin token. If got list of tokens test pass.""" login = self.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - logged_admins = self.request_session.get(generate_full_url(Endpoints.login_tockens), params=token) - self.check_status_code_200(logged_admins.status_code) - # print(logged_admins.text) - self.assertTrue(logged_admins.json().get("content"), "Content is empty") + alive_tokens = self.login_tockens(login.json().get("content")) + self.check_status_code_200(alive_tokens.status_code) + self.assertTrue(alive_tokens.json().get("content"), "Content is empty") def test_login_tockens_users(self): """Get alive tockens without admin token. If list of tokens empty test pass""" - for user, password in users.items(): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json() - token["token"] = token.pop("content") - logged_admins = self.request_session.get(generate_full_url(Endpoints.login_tockens), params=token) - self.check_status_code_200(logged_admins.status_code) - # print(logged_admins.text) - self.assertFalse(logged_admins.json().get("content"), "Content is not empty") - - -users = {"akimatc": "qwerty", - "khalaktc": "qwerty", - "kilinatc": "qwerty", - "OKonokhtc": "qwerty", - "otlumtc": "qwerty", - "slototc": "qwerty", - "vbudktc": "qwerty", - "vvasylystc": "qwerty"} + login = self.login(Users.valid_user, Users.valid_password) + self.check_status_code_200(login.status_code) + alive_tokens = self.login_tockens(login.json().get("content")) + self.check_status_code_200(alive_tokens.status_code) + self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") + + def test_login_tockens_users_default_token(self): + """Get alive tockens with default token. If list of tokens empty test pass""" + alive_tokens = self.login_tockens(DefaultToken.token) + self.check_status_code_200(alive_tokens.status_code) + self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_logout.py b/tests/functional/tests_logout.py index 63b5404..08cab41 100644 --- a/tests/functional/tests_logout.py +++ b/tests/functional/tests_logout.py @@ -1,49 +1,51 @@ -""" -Functional tests for logout users -""" +"""Functional tests for logout users""" -from tests.constants.constants import InitUsers, InitInvalidUsers -from tests.functional import ApiTestBase +from tests.constants.constants import DefaultUser, Users, DefaultToken +from tests.functional import ApiTestBase, Ascertains -class TestLogout(ApiTestBase): - - def check_status_code_200(self, status_code: int): - self.assertEqual(status_code, 200, "Error response status code (expected 200)") +class TestLogout(ApiTestBase, Ascertains): + """Class for testing""" def test_logout(self): - """Logout users. If request true user logout and test pass""" - for user, password in InitUsers.users.items(): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json().get("content") - logout = self.logout(user, token) - self.check_status_code_200(logout.status_code) - # print(logout.text) - self.assertTrue(logout.json().get("content"), "User not logout") + """Logout user. If request true and user logout test pass.""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + logout = self.logout(DefaultUser.user, login.json().get("content")) + self.check_status_code_200(logout.status_code) + self.assertTrue(logout.json().get("content"), "User not logout") + + def test_logout_another_user(self): + """Login user1, logout another user2 with user1 token. + If request false and user2 didn't logout test pass.""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + logout = self.logout(Users.valid_user, login.json().get("content")) + self.check_status_code_200(logout.status_code) + self.assertFalse(logout.json().get("content"), "User logout") + + def test_logout_another_token(self): + """Login user, logout with another token. + If request false and user didn't logout test pass.""" + login = self.login(DefaultUser.user, DefaultUser.password) + self.check_status_code_200(login.status_code) + logout = self.logout(DefaultUser.user, DefaultToken.token) + self.check_status_code_200(logout.status_code) + self.assertFalse(logout.json().get("content"), "User logout") def test_logout_fake_users(self): - """Logout fake users. If request false user didn't logout and test pass""" - for user, password in InitInvalidUsers.invalid_users.items(): - login = self.login(user, password) - # print(login.text) - self.check_status_code_200(login.status_code) - token = login.json().get("content") - logout = self.logout(user, token) - self.check_status_code_200(logout.status_code) - # print(logout.text) - self.assertFalse(logout.json().get("content"), "User logout") + """Logout fake user. If request false and user didn't logout test pass.""" + login = self.login(Users.fake_user, Users.fake_password) + self.check_status_code_200(login.status_code) + logout = self.logout(Users.fake_user, login.json().get("content")) + self.check_status_code_200(logout.status_code) + self.assertFalse(logout.json().get("content"), "User logout") def test_logout_locked_users(self): - """Logout locked users. If request false user didn't logout and test pass""" - for user, password in InitInvalidUsers.invalid_users.items(): - for i in range(3): - login = self.login(user, password) - self.check_status_code_200(login.status_code) - # print(login.text) - token = login.json().get("content") - logout = self.logout(user, token) - self.check_status_code_200(logout.status_code) - # print(logout.text) - self.assertFalse(logout.json().get("content"), "User logout") + """Logout locked user. If request false user didn't logout and test pass.""" + for _ in range(4): + login = self.login(Users.valid_user, Users.fake_password) + self.check_status_code_200(login.status_code) + logout = self.logout(Users.fake_user, login.json().get("content")) + self.check_status_code_200(logout.status_code) + self.assertFalse(logout.json().get("content"), "User logout") diff --git a/tests/utils/helper.py b/tests/utils/helper.py index f75f75e..214c4ac 100644 --- a/tests/utils/helper.py +++ b/tests/utils/helper.py @@ -1,5 +1,8 @@ +"""Help functions for testing""" + from tests.constants.constants import BaseUrl def generate_full_url(path): + """Generate the full url with base url and path""" return "{}{}".format(BaseUrl.base_url, path) From b5784be0484b43f88d08a13afcdb36e031cc34f2 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Mon, 29 Oct 2018 21:21:00 +0200 Subject: [PATCH 36/74] added test for getting user name --- tests/functional/tests_get_user_name.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 tests/functional/tests_get_user_name.py diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py new file mode 100644 index 0000000..c8c843b --- /dev/null +++ b/tests/functional/tests_get_user_name.py @@ -0,0 +1,21 @@ +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import DefaultUser, Endpoints +from tests.utils.helper import generate_full_url + + +class TestGetLoggedName(ApiTestBase): + + def test_get_user_name(self): + #login with user + login = self.login("slototc", "qwerty") + token = login.json()['content'] + # get user name from response + response = requests.get(generate_full_url(Endpoints.user), params={'token': token}) + returned_user_name = response.json()['content'] + self.assertEqual(200, response.status_code) + self.assertEqual("slototc", returned_user_name) + + + From 72ef67e909204ee1ee2fe9d21398cd26a7bd736a Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Tue, 30 Oct 2018 00:47:14 +0200 Subject: [PATCH 37/74] Refactoring code --- tests/functional/__init__.py | 18 ++++++--- tests/functional/tests_add_item.py | 39 +++++++++++------- tests/functional/tests_all_items.py | 9 +++-- tests/functional/tests_delete_item.py | 31 +++++++++----- tests/functional/tests_get_all_items_user.py | 40 ++++++++++++------- tests/functional/tests_get_item_by_index.py | 37 +++++++++++------ ...emindexes.py => tests_get_item_indexes.py} | 25 +++++++----- .../tests_get_user_item_by_index.py | 19 +++++---- tests/functional/tests_login.py | 11 ----- tests/functional/tests_update_item.py | 37 +++++++++++------ 10 files changed, 166 insertions(+), 100 deletions(-) rename tests/functional/{tests_get_itemindexes.py => tests_get_item_indexes.py} (68%) delete mode 100644 tests/functional/tests_login.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 455c33a..e94fe41 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -16,32 +16,40 @@ def reset(self): def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) - def get_user_all_items(self, user, admintoken): + def get_user_all_items(self, user, admin_token): + """Get all user items""" return self.request_session.get(generate_full_url(Endpoints.item_user).format(name=user), - params={"token": admintoken}) + params={"token": admin_token}) - def get_user_item_by_index(self, index, user, admintoken): + def get_user_item_by_index(self, index, user, admin_token): + """Get user item by index""" return self.request_session.get(generate_full_url(Endpoints.item_user_by_index).format(index=index, name=user), - params={"token": admintoken}) + params={"token": admin_token}) def add_item(self, index, token, item): + """Add item""" return self.request_session.post(generate_full_url(Endpoints.item).format(index=index), params={"token": token, "item": item}) def delete_item(self, index, token): + """Delete item""" return self.request_session.delete(generate_full_url(Endpoints.item).format(index=index), params={"token": token}) def update_item(self, index, token, item): + """Update item""" return self.request_session.put(generate_full_url(Endpoints.item).format(index=index), params={"token": token, "item": item}) def get_item(self, index, token): + """Get item by index""" return self.request_session.get(generate_full_url(Endpoints.item).format(index=index), params={"token": token}) - def get_itemindexes(self, token): + def get_item_indexes(self, token): + """Get all item indexes""" return self.request_session.get(generate_full_url(Endpoints.itemindexes), params={"token": token}) def get_all_items(self, token): + """Get all items by user""" return self.request_session.get(generate_full_url(Endpoints.items), params={"token": token}) diff --git a/tests/functional/tests_add_item.py b/tests/functional/tests_add_item.py index 80f9262..607d0c9 100644 --- a/tests/functional/tests_add_item.py +++ b/tests/functional/tests_add_item.py @@ -1,13 +1,16 @@ -from tests.functional import ApiTestBase +"""Functional tests for add item""" + from random import choice, randint +from tests.functional import ApiTestBase from tests.constants.constants import InitUsers, INVALID_TOKEN, VALID_STATUS_CODE, ITEM_NAMES -item_index = randint(0, 1000) -item_name = choice(ITEM_NAMES) +ITEM_INDEX = randint(0, 1000) +ITEM_NAME = choice(ITEM_NAMES) class TestAddItem(ApiTestBase): + """Class for tests add item""" def setUp(self): super().setUp() @@ -18,36 +21,44 @@ def tearDown(self): self.reset() def test_add_item_positive(self): - """test with valid token""" + """Test add item with valid token""" counter = 0 for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - add_item_user_response = self.add_item(counter, token, item_name) + add_item_user_response = self.add_item(counter, token, ITEM_NAME) counter = counter + 1 self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertTrue(add_item_user_response.json()["content"]) def test_add_specific_item(self): - """test add item with specific item""" + """Test add item with specific item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - get_item_response = self.get_item(item_index, token) - self.assertEqual(item_name, get_item_response.json()["content"]) + self.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_response = self.get_item(ITEM_INDEX, token) + self.assertEqual(ITEM_NAME, get_item_response.json()["content"]) def test_add_item_negative(self): - """test with invalid token""" - token = INVALID_TOKEN - add_item_user_response = self.add_item(item_index, token, item_name) + """Test add item with invalid token""" + add_item_user_response = self.add_item(ITEM_INDEX, INVALID_TOKEN, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertFalse(add_item_user_response.json()["content"]) def test_add_item_invalid_index(self): - """test add item when index not int""" + """Test add item when index not int""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - add_item_user_response = self.add_item(item_name, token, item_name) + add_item_user_response = self.add_item(ITEM_NAME, token, ITEM_NAME) self.assertNotEqual(VALID_STATUS_CODE, add_item_user_response.status_code) + + def test_add_int_item(self): + """Test add item with only number""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + add_item_user_response = self.add_item(ITEM_INDEX, token, ITEM_INDEX) + self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) + self.assertFalse(add_item_user_response.json()["content"]) diff --git a/tests/functional/tests_all_items.py b/tests/functional/tests_all_items.py index 69a20ea..abe6825 100644 --- a/tests/functional/tests_all_items.py +++ b/tests/functional/tests_all_items.py @@ -1,8 +1,11 @@ +"""Functional tests for all items""" + from tests.functional import ApiTestBase from tests.constants.constants import InitUsers, INVALID_TOKEN, VALID_STATUS_CODE class TestAllItems(ApiTestBase): + """Class for tests of all items""" def setUp(self): super().setUp() @@ -13,7 +16,7 @@ def tearDown(self): self.reset() def test_without_items(self): - """test when users have not any items""" + """Test get all items when user has not any items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] @@ -22,7 +25,7 @@ def test_without_items(self): self.assertFalse(get_all_items_response.json()["content"]) def test_with_items(self): - """test when users have items""" + """Test get all items when user has items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] @@ -34,7 +37,7 @@ def test_with_items(self): self.assertTrue(get_all_items_response.json()["content"]) def test_items_by_invalid_token(self): - """test with invalid token""" + """Test get all items with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] diff --git a/tests/functional/tests_delete_item.py b/tests/functional/tests_delete_item.py index 5c1bce3..bd63e33 100644 --- a/tests/functional/tests_delete_item.py +++ b/tests/functional/tests_delete_item.py @@ -1,13 +1,16 @@ -from tests.functional import ApiTestBase +"""Functional tests for delete item""" + from random import randint, choice -from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN -item_name = choice(ITEM_NAMES) -item_index = randint(0, 1000) +ITEM_NAME = choice(ITEM_NAMES) +ITEM_INDEX = randint(0, 1000) class TestDeleteItem(ApiTestBase): + """Class for tests of delete item""" def setUp(self): super().setUp() @@ -18,20 +21,30 @@ def tearDown(self): self.reset() def test_delete_empty_item(self): - """delete when users have not any items""" + """Test delete item when user has not any items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - delete_item_response = self.delete_item(item_index, token) + delete_item_response = self.delete_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) self.assertFalse(delete_item_response.json()["content"]) def test_delete_item(self): - """delete when user has item""" + """Test delete item when user has item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - delete_item_response = self.delete_item(item_index, token) + self.add_item(ITEM_INDEX, token, ITEM_NAME) + delete_item_response = self.delete_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) self.assertTrue(delete_item_response.json()["content"]) + + def test_delete_item_invalid_token(self): + """Test delete item with invalid token""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.login(user, password).json()["content"] + self.add_item(ITEM_INDEX, token, ITEM_NAME) + delete_item_response = self.delete_item(ITEM_INDEX, INVALID_TOKEN) + self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) + self.assertFalse(delete_item_response.json()["content"]) diff --git a/tests/functional/tests_get_all_items_user.py b/tests/functional/tests_get_all_items_user.py index 94e251e..430ac61 100644 --- a/tests/functional/tests_get_all_items_user.py +++ b/tests/functional/tests_get_all_items_user.py @@ -1,13 +1,16 @@ -from tests.functional import ApiTestBase +"""Functional tests for get all items""" + from random import choice, randint +from tests.functional import ApiTestBase from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN -item_index = randint(0, 1000) -item_name = choice(ITEM_NAMES) +ITEM_INDEX = randint(0, 1000) +ITEM_NAME = choice(ITEM_NAMES) class TestAllUserItems(ApiTestBase): + """Class for tests of get all items""" def setUp(self): super().setUp() @@ -18,7 +21,7 @@ def tearDown(self): self.reset() def test_get_items_by_admin(self): - """get user items with admintoken""" + """Test get user items with admintoken""" admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] for user in InitUsers.users: with self.subTest(i=user): @@ -27,7 +30,7 @@ def test_get_items_by_admin(self): self.assertFalse(get_items_user_response.json()["content"]) def test_get_items_by_admin_with_invalid_token(self): - """get items by admin with invalid token""" + """Test get items by admin with invalid token""" self.login(DefaultUser.user, DefaultUser.password) for user in InitUsers.users: with self.subTest(i=user): @@ -36,34 +39,41 @@ def test_get_items_by_admin_with_invalid_token(self): self.assertFalse(get_items_user_response.json()["content"]) def test_get_added_items_by_admin(self): - """get added user items by admin""" + """Test get added user items by admin""" for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + self.add_item(ITEM_INDEX, token, ITEM_NAME) + admin_token = self.login(DefaultUser.user, DefaultUser.password).json()["content"] for user in InitUsers.users: with self.subTest(i=user): - get_items_user_response = self.get_user_all_items(user, admintoken) + get_items_user_response = self.get_user_all_items(user, admin_token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertTrue(get_items_user_response.json()["content"]) + def test_get_items_invalid_user(self): + """Test get item invalid user""" + admin_token = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + get_items_user_response = self.get_user_all_items(ITEM_NAME, admin_token) + self.assertNotEqual(VALID_STATUS_CODE, get_items_user_response.status_code) + self.assertIn("Error", get_items_user_response.text) + def test_get_items_by_user(self): - """get user items with user token""" + """Test get user items with user token""" for user in InitUsers.users: with self.subTest(i=user): - token = self.login("kilinatc", "password").json()["content"] + token = self.login("kilinatc", "qwerty").json()["content"] get_items_user_response = self.get_user_all_items(user, token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) def test_get_added_items_by_user(self): - """get added user items by user""" + """Test get added user items by user token""" for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - admintoken = self.login("akinatc", "password").json()["content"] + self.add_item(ITEM_INDEX, token, ITEM_NAME) + token = self.login("akinatc", "qwerty").json()["content"] for user in InitUsers.users: with self.subTest(i=user): - get_items_user_response = self.get_user_all_items(user, admintoken) + get_items_user_response = self.get_user_all_items(user, token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) diff --git a/tests/functional/tests_get_item_by_index.py b/tests/functional/tests_get_item_by_index.py index c15092c..afd4407 100644 --- a/tests/functional/tests_get_item_by_index.py +++ b/tests/functional/tests_get_item_by_index.py @@ -1,13 +1,16 @@ -from tests.functional import ApiTestBase +"""Functional tests for get item by index""" + from random import choice, randint -from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN -item_index = randint(0, 1000) -item_name = choice(ITEM_NAMES) +ITEM_INDEX = randint(0, 1000) +ITEM_NAME = choice(ITEM_NAMES) class TestGetItemByIndex(ApiTestBase): + """Class for tests of get item by index""" def setUp(self): super().setUp() @@ -18,30 +21,40 @@ def tearDown(self): self.reset() def test_get_empty_item(self): - """test when users have not items""" + """Test get item by index when user has not items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - get_item_response = self.get_item(item_index, token) + get_item_response = self.get_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) self.assertFalse(get_item_response.json()["content"]) def test_get_item(self): - """test when users have item""" + """Test get item by index when user has item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - get_item_response = self.get_item(item_index, token) + self.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_response = self.get_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) self.assertTrue(get_item_response.json()["content"]) - self.assertEqual(item_name, get_item_response.json()["content"]) + self.assertEqual(ITEM_NAME, get_item_response.json()["content"]) def test_get_item_index_str(self): - """test get item with str index""" + """Test get item by index with str index""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) + self.add_item(ITEM_INDEX, token, ITEM_NAME) get_item_response = self.get_item("call", token) self.assertNotEqual(VALID_STATUS_CODE, get_item_response.status_code) + self.assertIn("Bad Request", get_item_response.text) + + def test_get_item_index_invalid_token(self): + """Test get item by index with invalid token""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + self.login(user, password) + get_item_response = self.get_item(ITEM_INDEX, INVALID_TOKEN) + self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) + self.assertFalse(get_item_response.json()["content"]) diff --git a/tests/functional/tests_get_itemindexes.py b/tests/functional/tests_get_item_indexes.py similarity index 68% rename from tests/functional/tests_get_itemindexes.py rename to tests/functional/tests_get_item_indexes.py index bb25cb2..5d6d016 100644 --- a/tests/functional/tests_get_itemindexes.py +++ b/tests/functional/tests_get_item_indexes.py @@ -1,13 +1,16 @@ -from tests.functional import ApiTestBase +"""Functional tests for get item indexes""" + from random import choice, randint +from tests.functional import ApiTestBase from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN -item_name = choice(ITEM_NAMES) -item_index = randint(0, 1000) +ITEM_NAME = choice(ITEM_NAMES) +ITEM_INDEX = randint(0, 1000) class TestGetItemIndexes(ApiTestBase): + """Class for tests of get item indexes""" def setUp(self): super().setUp() @@ -18,30 +21,30 @@ def tearDown(self): self.reset() def test_get_empty_item_indexes(self): - """test when user have not item indexes""" + """Test get item indexes when user has not item indexes""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - get_item_indexes_response = self.get_itemindexes(token) + get_item_indexes_response = self.get_item_indexes(token) self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) self.assertFalse(get_item_indexes_response.json()["content"]) def test_get_item_indexes(self): - """test get when user have any item""" + """Test get item indexes when user has any item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - get_item_indexes_response = self.get_itemindexes(token) + self.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_indexes_response = self.get_item_indexes(token) self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) self.assertTrue(get_item_indexes_response.json()["content"]) def test_get_item_indexes_by_invalid_token(self): - """test get item indexes with invalid token""" + """Test get item indexes with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - get_item_indexes_response = self.get_itemindexes(INVALID_TOKEN) + self.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_indexes_response = self.get_item_indexes(INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) self.assertFalse(get_item_indexes_response.json()["content"]) diff --git a/tests/functional/tests_get_user_item_by_index.py b/tests/functional/tests_get_user_item_by_index.py index d68b289..8e00f02 100644 --- a/tests/functional/tests_get_user_item_by_index.py +++ b/tests/functional/tests_get_user_item_by_index.py @@ -1,12 +1,15 @@ -from tests.functional import ApiTestBase +"""Functional tests for get user item by index""" + from random import randint +from tests.functional import ApiTestBase from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE, INVALID_TOKEN -item_index = randint(0, 1000) +ITEM_INDEX = randint(0, 1000) class TestUserItemByIndex(ApiTestBase): + """Class for tests of get user item by index""" def setUp(self): super().setUp() @@ -17,15 +20,15 @@ def tearDown(self): self.reset() def test_get_user_item_by_admin(self): - """get user item with admin token""" + """Test get user item by index with admin token""" for user in dict.keys(InitUsers.users): - admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] - get_item_user_response = self.get_user_item_by_index(item_index, user, admintoken) + admin_token = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + get_item_user_response = self.get_user_item_by_index(ITEM_INDEX, user, admin_token) self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertFalse(get_item_user_response.json()["content"]) def test_get_user_item_by_user(self): - """get user item with user token""" + """Test get user item by index with user token""" counter = 0 for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] @@ -35,9 +38,9 @@ def test_get_user_item_by_user(self): self.assertFalse(get_item_user_response.json()["content"]) def test_get_user_item_by_invalid_token(self): - """get user item with invalid token""" + """Test get user item by index with invalid token""" for user in dict.keys(InitUsers.users): self.login(DefaultUser.user, DefaultUser.password) - get_item_user_response = self.get_user_item_by_index(item_index, user, INVALID_TOKEN) + get_item_user_response = self.get_user_item_by_index(ITEM_INDEX, user, INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertFalse(get_item_user_response.json()["content"]) diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py deleted file mode 100644 index f0c43ba..0000000 --- a/tests/functional/tests_login.py +++ /dev/null @@ -1,11 +0,0 @@ -import requests - -from tests.functional import ApiTestBase -from tests.constants.constants import InitUsers - -class Test(ApiTestBase): - - def test_login(self): - # sceleton, not refactoring - login = self.login("admin", "qwerty") - self.assertEquals(200, login.status_code) diff --git a/tests/functional/tests_update_item.py b/tests/functional/tests_update_item.py index 06b520a..6ca68d8 100644 --- a/tests/functional/tests_update_item.py +++ b/tests/functional/tests_update_item.py @@ -1,13 +1,16 @@ -from tests.functional import ApiTestBase +"""Functional tests for update item""" + from random import choice, randint -from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES +from tests.functional import ApiTestBase +from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN -item_index = randint(0, 1000) -item_name = choice(ITEM_NAMES) +ITEM_INDEX = randint(0, 1000) +ITEM_NAME = choice(ITEM_NAMES) class TestUpdateItem(ApiTestBase): + """Class for tests of update item""" def setUp(self): super().setUp() @@ -18,28 +21,38 @@ def tearDown(self): self.reset() def test_update_empty_item(self): - """test update item when user has no item""" + """Test update item when user has no item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - update_item_response = self.update_item(item_index, token, item_name) + update_item_response = self.update_item(ITEM_INDEX, token, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertFalse(update_item_response.json()["content"]) def test_update_item(self): - """test update item when user has item""" + """Test update item when user has item""" for user, password in InitUsers.users.items(): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - update_item_response = self.update_item(item_index, token, item_name) + self.add_item(ITEM_INDEX, token, ITEM_NAME) + update_item_response = self.update_item(ITEM_INDEX, token, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertTrue(update_item_response.json()["content"]) def test_update_item_invalid_index(self): - """test update item when index not int""" + """Test update item when index not int""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.login(user, password).json()["content"] - self.add_item(item_index, token, item_name) - update_item_response = self.update_item(item_name, token, item_name) + self.add_item(ITEM_INDEX, token, ITEM_NAME) + update_item_response = self.update_item(ITEM_NAME, token, ITEM_NAME) self.assertNotEqual(VALID_STATUS_CODE, update_item_response.status_code) + self.assertIn("Bad Request", update_item_response.text) + + def test_update_item_invalid_token(self): + """Test update item with invalid token""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + self.login(user, password) + update_item_response = self.update_item(ITEM_INDEX, INVALID_TOKEN, ITEM_NAME) + self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) + self.assertFalse(update_item_response.json()["content"]) From 62ec7dd8c9343ea06b6080734f56e3d817dd2a5b Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Tue, 30 Oct 2018 09:09:30 +0200 Subject: [PATCH 38/74] edited previous and added new tests to removing user --- tests/functional/__init__.py | 4 + tests/functional/test_user_remove.py | 30 ----- tests/functional/tests_get_user_name.py | 15 ++- tests/functional/tests_user_create_new.py | 13 +++ tests/functional/tests_user_remove.py | 130 ++++++++++++++++++++++ 5 files changed, 160 insertions(+), 32 deletions(-) delete mode 100644 tests/functional/test_user_remove.py create mode 100644 tests/functional/tests_user_remove.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 6582313..e339995 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -25,6 +25,10 @@ def change_pass(self, token, oldpassword, newpassword): return self.request_session.put(generate_full_url(Endpoints.user), {"token": token, "oldpassword": oldpassword, "newpassword": newpassword}) + def delete_user(self, adminToken, name): + return self.request_session.delete(generate_full_url(Endpoints.user), params ={"token": adminToken, + "name": name}) + def tearDown(self): return self.request_session.get(generate_full_url(Endpoints.reset)) diff --git a/tests/functional/test_user_remove.py b/tests/functional/test_user_remove.py deleted file mode 100644 index ebab3ae..0000000 --- a/tests/functional/test_user_remove.py +++ /dev/null @@ -1,30 +0,0 @@ -import requests - -from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser -from tests.utils.helper import generate_full_url - - -class TestRemoveUser(ApiTestBase): - - def setUp(self): - super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] - - def test_remove_User_with_valid_data(self): - # create test_user - creating = requests.post(generate_full_url(Endpoints.user), params={'token': self.adminToken, "name": "testuserdelete", - "password": "qwerty", "rights": "false"}) - #delete test user - remove_created_user = requests.delete(generate_full_url(Endpoints.user), - params={'token': self.adminToken, "name": "testuserdelete"}) - self.assertIn("true", remove_created_user.text) - - - def test_login_deleted_user(self): - deleted_user_login = requests.post(generate_full_url(Endpoints.login), - params = {"name": "testuserdelete", "password": "qwerty"}) - self.assertIn("ERROR", deleted_user_login.text, "Error, user not deleted") - - diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py index c8c843b..f408c18 100644 --- a/tests/functional/tests_get_user_name.py +++ b/tests/functional/tests_get_user_name.py @@ -1,21 +1,32 @@ import requests from tests.functional import ApiTestBase -from tests.constants.constants import DefaultUser, Endpoints +from tests.constants.constants import Endpoints, DefaultUser from tests.utils.helper import generate_full_url class TestGetLoggedName(ApiTestBase): def test_get_user_name(self): - #login with user + + # login with user login = self.login("slototc", "qwerty") token = login.json()['content'] + # get user name from response response = requests.get(generate_full_url(Endpoints.user), params={'token': token}) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) self.assertEqual("slototc", returned_user_name) + def test_get_username_with_invalid_token(self): + """Get username with invalid token""" + login = self.login("vvasylystc", "qwerty") + token = login.json()['content'] + "WK" + # get user name from response + response = requests.get(generate_full_url(Endpoints.user), params={'token': token}) + returned_user_name = response.json()['content'] + self.assertEqual(200, response.status_code) + self.assertEqual("vvasylystc", returned_user_name) diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index bd90679..444f191 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -24,6 +24,19 @@ def test_create_new_user(self): self.assertEqual(32, len_of_new_user_token) self.tearDown() + def test_create_new_with_exist_name(self): + + """create new user with already exist name""" + + create_new_user = self.create_new_user(self.adminToken, "admin", "Pass", "false") + self.assertIn("true", create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + login = self.login("admin", "Pass") + len_of_new_user_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with a name what already exist") + self.tearDown() + def test_create_user_with_non_admin_token(self): """create new user with usage of non admin token""" diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py new file mode 100644 index 0000000..4652b4f --- /dev/null +++ b/tests/functional/tests_user_remove.py @@ -0,0 +1,130 @@ +import requests + +from tests.functional import ApiTestBase +from tests.constants.constants import Endpoints, DefaultUser +from tests.utils.helper import generate_full_url + + +class TestRemoveUser(ApiTestBase): + + def setUp(self): + + """Get admin token""" + + super().setUp() + response = self.login(DefaultUser.user, DefaultUser.password) + self.adminToken = response.json()['content'] + + def tearDown(self): + + """Reset api after each test""" + requests.get(generate_full_url(Endpoints.reset)) + + def test_remove_user(self): + + """delete user with valid data""" + + removed_user = self.delete_user(self.adminToken, "akimatc") + get_answer = str(removed_user.json()['content']) + self.assertIn('True', get_answer) + self.assertEqual(200, removed_user.status_code) + + # Try to login with removed user + + login = self.login("akimatc", "qwerty") + response = login.json()['content'] + let_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertNotIn('True', str(login.content)) + self.assertNotEqual(32, let_token) + self.assertEqual('ERROR, user not found', response) + + + def test_admin_delete_himself(self): + + """Delete admin""" + + removed_user = self.delete_user(self.adminToken, DefaultUser.user) + get_answer = str(removed_user.json()['content']) + self.assertIn('True', get_answer) + self.assertEqual(200, removed_user.status_code) + + # Try to login with deleted admin + + login = self.login(DefaultUser.user, DefaultUser.password) + response = login.json()['content'] + let_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertNotIn('True', str(login.content)) + self.assertNotEqual(32, let_token) + self.assertEqual('ERROR, user not found', response) + + + def test_user_detele_himself(self): + + """User delete himself with user token""" + + login = self.login("akimatc", "qwerty") + token = login.json()['content'] + let_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertEqual(32, let_token) + + # Use User token to delete himself + removed_user = self.delete_user(token, "akimatc") + get_answer = str(removed_user.json()['content']) + self.assertEqual(200, removed_user.status_code) + self.assertIn('False', get_answer, 'ERROR. User was deleted with user token!') + self.assertNotEqual(32, len(get_answer)) + + + def test_user_token_delete_admin(self): + + """Login with user and use user token to delete admin""" + + login = self.login("akimatc", "qwerty") + token = login.json()['content'] + let_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertEqual(32, let_token) + + # del admin with user token + removed_user = self.delete_user(token, "admin") + get_answer = str(removed_user.json()['content']) + self.assertEqual(200, removed_user.status_code) + self.assertIn('False', get_answer, 'ERROR. Admin was deleted with user token!') + self.assertNotEqual(32, len(get_answer)) + + def test_admin_token_not_right(self): + + """Use wrong token""" + + invalid_token = "0123456789ABCDEF0123456789ABCDEF" + removed_user = self.delete_user(invalid_token, "akimatc") + get_answer = str(removed_user.json()['content']) + self.assertEqual(200, removed_user.status_code) + self.assertNotIn('True', get_answer) + + def test_user_not_exist_deletion(self): + ... + + # + # def test_user_not_valid(self): + # ... + # + # def test_token_not_valid(self): + # ... + # def test_remove_User_with_valid_data(self): + # + # #delete test user + # remove_created_user = requests.delete(generate_full_url(Endpoints.user), + # params={'token': self.adminToken, "name": "testuserdelete"}) + # self.assertIn("true", remove_created_user.text) + # + # + # def test_login_deleted_user(self): + # deleted_user_login = requests.post(generate_full_url(Endpoints.login), + # params = {"name": "testuserdelete", "password": "qwerty"}) + # self.assertIn("ERROR", deleted_user_login.text, "Error, user not deleted") + # + From 8e3d17e0c6dd111c414e7e1f08495e9c56984537 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Tue, 30 Oct 2018 10:41:34 +0200 Subject: [PATCH 39/74] added new tests for deleting users --- tests/functional/tests_user_remove.py | 39 +++++++++++++-------------- 1 file changed, 18 insertions(+), 21 deletions(-) diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py index 4652b4f..aee5896 100644 --- a/tests/functional/tests_user_remove.py +++ b/tests/functional/tests_user_remove.py @@ -102,29 +102,26 @@ def test_admin_token_not_right(self): invalid_token = "0123456789ABCDEF0123456789ABCDEF" removed_user = self.delete_user(invalid_token, "akimatc") get_answer = str(removed_user.json()['content']) + len_token = len(get_answer) self.assertEqual(200, removed_user.status_code) self.assertNotIn('True', get_answer) + self.assertNotEqual(32, len_token) def test_user_not_exist_deletion(self): - ... - - # - # def test_user_not_valid(self): - # ... - # - # def test_token_not_valid(self): - # ... - # def test_remove_User_with_valid_data(self): - # - # #delete test user - # remove_created_user = requests.delete(generate_full_url(Endpoints.user), - # params={'token': self.adminToken, "name": "testuserdelete"}) - # self.assertIn("true", remove_created_user.text) - # - # - # def test_login_deleted_user(self): - # deleted_user_login = requests.post(generate_full_url(Endpoints.login), - # params = {"name": "testuserdelete", "password": "qwerty"}) - # self.assertIn("ERROR", deleted_user_login.text, "Error, user not deleted") - # + + """Detele not exist user""" + + removed_user = self.delete_user(self.adminToken, "testuser") + get_answer = str(removed_user.json()['content']) + self.assertEqual(200, removed_user.status_code) + self.assertNotIn('True', get_answer, "ERROR, we deleted not existed user") + + + def test_user_not_valid(self): + """Delete user with not valid name""" + + removed_user = self.delete_user(self.adminToken, "akimatg") + get_answer = str(removed_user.json()['content']) + self.assertEqual(200, removed_user.status_code) + self.assertNotIn('True', get_answer, "ERROR, we deleted user with wrong nickname") From f0bf4dba9189e82016a83f4ad1512f81d9a35e26 Mon Sep 17 00:00:00 2001 From: asstelite Date: Tue, 30 Oct 2018 11:48:53 +0200 Subject: [PATCH 40/74] just saving work --- tests/functional/tests_locked.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 977c581..8dc93ad 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -50,11 +50,12 @@ def test_manual_lock(self): """Test functionality of locking users by manual command""" users = list(InitUsers.users) users.remove('admin') - kwargs = {'token': self.adminToken, 'name': users[1]} - requests.post((generate_full_url(Endpoints.locked_user) + users[1]), params=kwargs) + user_to_lock = users[1] + kwargs = {'token': self.adminToken, 'name': user_to_lock} + requests.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) locked_users_request1 = self.get_locked_users(kwargs) locked_users = locked_users_request1.json()['content'] - s = '0 \t' + users[1] + '\n' + s = '0 \t' + user_to_lock + '\n' self.assertEqual(locked_users, s) def test_manual_unlock(self): From 1d0a334aa7abb99da56e89987a7f1035dd32fefc Mon Sep 17 00:00:00 2001 From: asstelite Date: Tue, 30 Oct 2018 12:20:24 +0200 Subject: [PATCH 41/74] just saving work --- tests/functional/__init__.py | 14 ++++++++++++++ tests/functional/tests_locked.py | 12 ++++++++++++ 2 files changed, 26 insertions(+) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 56f72f5..46e38ea 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -18,5 +18,19 @@ def login(self, name:str, password:str) -> object: def get_locked_users(self, kwargs): return self.request_session.get(generate_full_url(Endpoints.locked_users), params = kwargs) + def get_locked_admins(self, kwargs): + return self.request_session.get(generate_full_url(Endpoints.locked_admins), params = kwargs) + def get_logined_users(self, kwargs): return self.request_session.get(generate_full_url(Endpoints.login_users), params = kwargs) + + def logout(self, name: str, token: str): + return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) + + def create_new_user(self, adminToken, newName, newPassword, adminRights): + return self.request_session.post(generate_full_url(Endpoints.user), + {"token": adminToken, "name": newName, "password": newPassword, + "rights": adminRights}) + + def tearDown(self): + return self.request_session.get(generate_full_url(Endpoints.reset)) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 8dc93ad..ef60b51 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -84,3 +84,15 @@ def test_reset_locked(self): locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') + + def test_locked_admins(self): + """Test functionality of locking admins""" + new_user_name = 'Shtepsel' + new_user_pass = 'qwerty' + self.create_new_user(self.adminToken, new_user_name, new_user_pass, 'true') + passwords = ['', 'password', 'birthday', 'petname'] + for password in passwords: + self.login(new_user_name, password) + kwargs = {'token': self.adminToken} + locked_admins = self.get_locked_admins(kwargs) + self.assertIn(new_user_name, locked_admins.text) From 6ce4077d86253901c23df5ac869faec2a0aa248b Mon Sep 17 00:00:00 2001 From: abertash Date: Tue, 30 Oct 2018 12:22:38 +0200 Subject: [PATCH 42/74] change constants that other users will not have problems with renames. refactoring. --- tests/constants/constants.py | 9 +- tests/functional/tests_cooldowntime.py | 143 ++++++++++------------- tests/functional/tests_tokenlifetime.py | 145 ++++++++++-------------- tests/functional/tests_users.py | 11 +- tests/utils/helper.py | 16 ++- 5 files changed, 143 insertions(+), 181 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index 886d333..b40062b 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -3,11 +3,14 @@ class DefaultUser: - # user = "admin" - user = "akimatc" - admin = "admin" + user = "admin" password = "qwerty" + user_akimatc = "akimatc" + user_admin = "admin" + password_akimatc = "qwerty" + password_admin = "qwerty" + class DefaultToken: diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py index 75a4bfe..0c5a27a 100644 --- a/tests/functional/tests_cooldowntime.py +++ b/tests/functional/tests_cooldowntime.py @@ -1,187 +1,160 @@ from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser +from tests.utils.helper import get_new_value_different_func class TestCoolDownTime(ApiTestBase): + """ + Testing response of "/cooldowntime" + """ def test_get_cool_down_time(self): """ Get the value of cool down time - :return: """ - req = self.get_cool_down_time() + resp = self.get_cool_down_time() - self.assertEqual(req.status_code, 200) - self.assertTrue(req.ok) - self.assertTrue(req.json()["content"] or req.json()["content"] == 0) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"] or resp.json()["content"] == 0) def test_set_cool_down_time_admin_positive(self): """ Change the cool down time value by admin (positive) - :return: """ - new_CDT = self.get_new_cool_down_time(200000, 100000) + new_CDT = get_new_value_different_func(self.get_cool_down_time, 200000, 100000) - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_CDT) - last_req = self.get_cool_down_time() - CDT_after = last_req.json()["content"] + last_resp = self.get_cool_down_time() + CDT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(CDT_after, new_CDT) def test_set_cool_down_time_admin_negative(self): """ Change the cool down time value by admin (negative) - :return: """ - new_CDT = self.get_new_cool_down_time(-200000, -100000) + new_CDT = get_new_value_different_func(self.get_cool_down_time, -200000, -100000) - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_CDT) - last_req = self.get_cool_down_time() - CDT_after = last_req.json()["content"] + last_resp = self.get_cool_down_time() + CDT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(CDT_after, new_CDT) def test_set_cool_down_time_admin_zero(self): """ Change the cool down time value by admin (zero) - :return: """ - new_CDT = self.get_new_cool_down_time(0, 0) + new_CDT = get_new_value_different_func(self.get_cool_down_time, 0, 0) - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_CDT) - last_req = self.get_cool_down_time() - CDT_after = last_req.json()["content"] + last_resp = self.get_cool_down_time() + CDT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(CDT_after, new_CDT) def test_set_cool_down_time_admin_none(self): """ Change the cool down time value by admin (None) - :return: """ new_CDT = None def_CDT = 1000 - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_CDT) - last_req = self.get_cool_down_time() - CDT_after = last_req.json()["content"] + last_resp = self.get_cool_down_time() + CDT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(CDT_after, def_CDT) def test_set_cool_down_time_admin_float(self): """ Change the cool down time value by admin (float) - :return: """ - new_CDT = self.get_new_cool_down_time(200000.555, 100000) + new_CDT = get_new_value_different_func(self.get_cool_down_time, 200000.555, 100000) - req = self.get_cool_down_time() - curr_CDT = req.json()["content"] + resp = self.get_cool_down_time() + curr_CDT = resp.json()["content"] - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_CDT) - last_req = self.get_cool_down_time() - CDT_after = last_req.json()["content"] + last_resp = self.get_cool_down_time() + CDT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 400) - self.assertFalse(req.ok) + self.assertEqual(resp.status_code, 400) self.assertEqual(CDT_after, curr_CDT) def test_set_cool_down_time_admin_text(self): """ Change the cool down time value by admin (text) - :return: """ new_CDT = "f%kdm525!(" - req = self.get_cool_down_time() - curr_CDT = req.json()["content"] + resp = self.get_cool_down_time() + curr_CDT = resp.json()["content"] - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_CDT) - last_req = self.get_cool_down_time() - CDT_after = last_req.json()["content"] + last_resp = self.get_cool_down_time() + CDT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 400) - self.assertFalse(req.ok) + self.assertEqual(resp.status_code, 400) self.assertEqual(CDT_after, curr_CDT) def test_set_cool_down_time_user(self): """ Change the cool down time value by user (without admin rights) - :return: """ - new_CDT = self.get_new_cool_down_time(500000, 100000) + new_CDT = get_new_value_different_func(self.get_cool_down_time, 500000, 100000) - req = self.get_cool_down_time() - curr_CDT = req.json()["content"] + resp = self.get_cool_down_time() + curr_CDT = resp.json()["content"] - login = self.login(DefaultUser.user, DefaultUser.password) + login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] - req = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_CDT) - last_req = self.get_cool_down_time() - CDT_after = last_req.json()["content"] + last_resp = self.get_cool_down_time() + CDT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertFalse(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertFalse(resp.json()["content"]) self.assertEqual(CDT_after, curr_CDT) - - def get_new_cool_down_time(self, new_CDT, step): - """ - Get new cool down time (CDT) value. - If current CDT equal new value then we make greater new CDT by step - :return: - """ - - req = self.get_cool_down_time() - curr_CDT = req.json()["content"] - - if curr_CDT == new_CDT: - new_CDT = curr_CDT + step - - return new_CDT \ No newline at end of file diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py index 69ab712..003c675 100644 --- a/tests/functional/tests_tokenlifetime.py +++ b/tests/functional/tests_tokenlifetime.py @@ -1,97 +1,92 @@ from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser +from tests.utils.helper import get_new_value_different_func class TestTokenLifeTime(ApiTestBase): + """ + Testing response of "/tokenlifetime" + """ def test_get_token_life_time(self): """ Get the value of token life time - :return: """ - req = self.get_token_life_time() + resp = self.get_token_life_time() - self.assertEqual(req.status_code, 200) - self.assertTrue(req.ok) - self.assertTrue(req.json()["content"] or req.json()["content"] == 0) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"] or resp.json()["content"] == 0) def test_set_token_life_time_admin_positive(self): """ Change the token life time value by admin (positive) - :return: """ - # must use, because after et_token_life_time = 0, admin logout + # must use, because after get_token_life_time = 0, admin logout self.get_reset() - new_TLT = self.get_new_token_life_time(200000, 100000) + new_TLT = get_new_value_different_func(self.get_token_life_time, 200000, 100000) - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_TLT) - last_req = self.get_token_life_time() - TLT_after = last_req.json()["content"] + last_resp = self.get_token_life_time() + TLT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(TLT_after, new_TLT) def test_set_token_life_time_admin_negative(self): """ Change the token life time value by admin (negative) - :return: """ # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = self.get_new_token_life_time(-200000, -100000) + new_TLT = get_new_value_different_func(self.get_token_life_time, -200000, -100000) - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_TLT) - last_req = self.get_token_life_time() - TLT_after = last_req.json()["content"] + last_resp = self.get_token_life_time() + TLT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(TLT_after, new_TLT) def test_set_token_life_time_admin_zero(self): """ Change the token life time value by admin (zero) - :return: """ # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = self.get_new_token_life_time(0, 0) + new_TLT = get_new_value_different_func(self.get_token_life_time, 0, 0) - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_TLT) - last_req = self.get_token_life_time() - TLT_after = last_req.json()["content"] + last_resp = self.get_token_life_time() + TLT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(TLT_after, new_TLT) def test_set_token_life_time_admin_none(self): """ Change the token life time value by admin (None) - :return: """ # must use, because after et_token_life_time = 0, admin logout @@ -100,49 +95,45 @@ def test_set_token_life_time_admin_none(self): new_TLT = None def_TLT = 1000 - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_TLT) - last_req = self.get_token_life_time() - TLT_after = last_req.json()["content"] + last_resp = self.get_token_life_time() + TLT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertTrue(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertTrue(resp.json()["content"]) self.assertEqual(TLT_after, def_TLT) def test_set_token_life_time_admin_float(self): """ Change the token life time value by admin (float) - :return: """ # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = self.get_new_token_life_time(200000.555, 100000) + new_TLT = get_new_value_different_func(self.get_token_life_time, 200000.555, 100000) - req = self.get_token_life_time() - curr_TLT = req.json()["content"] + resp = self.get_token_life_time() + curr_TLT = resp.json()["content"] - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_TLT) - last_req = self.get_token_life_time() - TLT_after = last_req.json()["content"] + last_resp = self.get_token_life_time() + TLT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 400) - self.assertFalse(req.ok) + self.assertEqual(resp.status_code, 400) self.assertEqual(TLT_after, curr_TLT) def test_set_token_life_time_admin_text(self): """ Change the token life time value by admin (text) - :return: """ # must use, because after et_token_life_time = 0, admin logout @@ -150,59 +141,41 @@ def test_set_token_life_time_admin_text(self): new_TLT = "f%kdm525!(" - req = self.get_token_life_time() - curr_TLT = req.json()["content"] + resp = self.get_token_life_time() + curr_TLT = resp.json()["content"] - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_TLT) - last_req = self.get_token_life_time() - TLT_after = last_req.json()["content"] + last_resp = self.get_token_life_time() + TLT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 400) - self.assertFalse(req.ok) + self.assertEqual(resp.status_code, 400) self.assertEqual(TLT_after, curr_TLT) def test_set_token_life_time_user(self): """ Change the token life time value by user (without admin rights) - :return: """ # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = self.get_new_token_life_time(500000, 100000) + new_TLT = get_new_value_different_func(self.get_token_life_time, 500000, 100000) - req = self.get_token_life_time() - curr_TLT = req.json()["content"] + resp = self.get_token_life_time() + curr_TLT = resp.json()["content"] - login = self.login(DefaultUser.user, DefaultUser.password) + login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] - req = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_TLT) - last_req = self.get_token_life_time() - TLT_after = last_req.json()["content"] + last_resp = self.get_token_life_time() + TLT_after = last_resp.json()["content"] - self.assertEqual(req.status_code, 200) - self.assertFalse(req.json()["content"]) - self.assertTrue(req.ok) + self.assertEqual(resp.status_code, 200) + self.assertFalse(resp.json()["content"]) self.assertEqual(TLT_after, curr_TLT) - - def get_new_token_life_time(self, new_TLT, step): - """ - Get new token life time (TLT) value. - If current TLT equal new value then we make greater new TLT by step - :return: - """ - - req = self.get_token_life_time() - curr_TLT = req.json()["content"] - - if curr_TLT == new_TLT: - new_TLT = curr_TLT + step - - return new_TLT \ No newline at end of file diff --git a/tests/functional/tests_users.py b/tests/functional/tests_users.py index 89b0e7b..0a4ee3c 100644 --- a/tests/functional/tests_users.py +++ b/tests/functional/tests_users.py @@ -3,33 +3,32 @@ class TestUsers(ApiTestBase): + """ + Testing response of "/users" + """ def test_get_all_users_admin(self): """ Get the list of all users by admin - :return: """ - login = self.login(DefaultUser.admin, DefaultUser.password) + login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] req = self.get_all_users(token) self.assertEqual(req.status_code, 200) - self.assertTrue(req.ok) self.assertTrue(req.json()["content"]) def test_get_all_users_user(self): """ Get the list of all users by user (without admin rights) - :return: """ - login = self.login(DefaultUser.user, DefaultUser.password) + login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] req = self.get_all_users(token) self.assertEqual(req.status_code, 200) self.assertFalse(req.json()["content"]) - self.assertTrue(req.ok) diff --git a/tests/utils/helper.py b/tests/utils/helper.py index 59fe0e2..ca89c11 100644 --- a/tests/utils/helper.py +++ b/tests/utils/helper.py @@ -2,4 +2,18 @@ def generate_full_url(path): - return "{}{}".format(BaseUrl.base_url, path) \ No newline at end of file + return "{}{}".format(BaseUrl.base_url, path) + + +def get_new_value_different_func(func, new_value, step): + """ + Get new value which is different from returned function value. + The function compare returned func() value and new_value (parameters). + If they are equal then new_value increases by step. + The function return either new_value or new_value + step + """ + + resp = func() + func_value = resp.json()["content"] + + return new_value + step if func_value == new_value else new_value From a0c96bac21ee137c49f2bdb0f2a3bfb46c715345 Mon Sep 17 00:00:00 2001 From: abertash Date: Tue, 30 Oct 2018 12:34:35 +0200 Subject: [PATCH 43/74] change constants that other users will not have problems with renames. refactoring. --- tests/functional/__init__.py | 2 +- tests/functional/tests_cooldowntime.py | 68 +++++++++++++------------ tests/functional/tests_tokenlifetime.py | 68 +++++++++++++------------ tests/functional/tests_users.py | 4 ++ 4 files changed, 77 insertions(+), 65 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index fbdbd33..f0de437 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -31,4 +31,4 @@ def get_token_life_time(self): return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) def get_all_users(self, admin_token): - return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) \ No newline at end of file + return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py index 0c5a27a..79238fa 100644 --- a/tests/functional/tests_cooldowntime.py +++ b/tests/functional/tests_cooldowntime.py @@ -1,3 +1,7 @@ +""" +Testing response of "/cooldowntime" module +""" + from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser from tests.utils.helper import get_new_value_different_func @@ -23,138 +27,138 @@ def test_set_cool_down_time_admin_positive(self): Change the cool down time value by admin (positive) """ - new_CDT = get_new_value_different_func(self.get_cool_down_time, 200000, 100000) + new_cdt = get_new_value_different_func(self.get_cool_down_time, 200000, 100000) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_cdt) last_resp = self.get_cool_down_time() - CDT_after = last_resp.json()["content"] + cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(CDT_after, new_CDT) + self.assertEqual(cdt_after, new_cdt) def test_set_cool_down_time_admin_negative(self): """ Change the cool down time value by admin (negative) """ - new_CDT = get_new_value_different_func(self.get_cool_down_time, -200000, -100000) + new_cdt = get_new_value_different_func(self.get_cool_down_time, -200000, -100000) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_cdt) last_resp = self.get_cool_down_time() - CDT_after = last_resp.json()["content"] + cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(CDT_after, new_CDT) + self.assertEqual(cdt_after, new_cdt) def test_set_cool_down_time_admin_zero(self): """ Change the cool down time value by admin (zero) """ - new_CDT = get_new_value_different_func(self.get_cool_down_time, 0, 0) + new_cdt = get_new_value_different_func(self.get_cool_down_time, 0, 0) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_cdt) last_resp = self.get_cool_down_time() - CDT_after = last_resp.json()["content"] + cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(CDT_after, new_CDT) + self.assertEqual(cdt_after, new_cdt) def test_set_cool_down_time_admin_none(self): """ Change the cool down time value by admin (None) """ - new_CDT = None - def_CDT = 1000 + new_cdt = None + def_cdt = 1000 login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_cdt) last_resp = self.get_cool_down_time() - CDT_after = last_resp.json()["content"] + cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(CDT_after, def_CDT) + self.assertEqual(cdt_after, def_cdt) def test_set_cool_down_time_admin_float(self): """ Change the cool down time value by admin (float) """ - new_CDT = get_new_value_different_func(self.get_cool_down_time, 200000.555, 100000) + new_cdt = get_new_value_different_func(self.get_cool_down_time, 200000.555, 100000) resp = self.get_cool_down_time() - curr_CDT = resp.json()["content"] + curr_cdt = resp.json()["content"] login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_cdt) last_resp = self.get_cool_down_time() - CDT_after = last_resp.json()["content"] + cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) - self.assertEqual(CDT_after, curr_CDT) + self.assertEqual(cdt_after, curr_cdt) def test_set_cool_down_time_admin_text(self): """ Change the cool down time value by admin (text) """ - new_CDT = "f%kdm525!(" + new_cdt = "f%kdm525!(" resp = self.get_cool_down_time() - curr_CDT = resp.json()["content"] + curr_cdt = resp.json()["content"] login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_cdt) last_resp = self.get_cool_down_time() - CDT_after = last_resp.json()["content"] + cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) - self.assertEqual(CDT_after, curr_CDT) + self.assertEqual(cdt_after, curr_cdt) def test_set_cool_down_time_user(self): """ Change the cool down time value by user (without admin rights) """ - new_CDT = get_new_value_different_func(self.get_cool_down_time, 500000, 100000) + new_cdt = get_new_value_different_func(self.get_cool_down_time, 500000, 100000) resp = self.get_cool_down_time() - curr_CDT = resp.json()["content"] + curr_cdt = resp.json()["content"] login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_CDT) + resp = self.change_cool_down_time(token, new_cdt) last_resp = self.get_cool_down_time() - CDT_after = last_resp.json()["content"] + cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertFalse(resp.json()["content"]) - self.assertEqual(CDT_after, curr_CDT) + self.assertEqual(cdt_after, curr_cdt) diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py index 003c675..bef80b3 100644 --- a/tests/functional/tests_tokenlifetime.py +++ b/tests/functional/tests_tokenlifetime.py @@ -1,3 +1,7 @@ +""" +Testing response of "/tokenlifetime" module +""" + from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser from tests.utils.helper import get_new_value_different_func @@ -26,19 +30,19 @@ def test_set_token_life_time_admin_positive(self): # must use, because after get_token_life_time = 0, admin logout self.get_reset() - new_TLT = get_new_value_different_func(self.get_token_life_time, 200000, 100000) + new_tlt = get_new_value_different_func(self.get_token_life_time, 200000, 100000) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_tlt) last_resp = self.get_token_life_time() - TLT_after = last_resp.json()["content"] + tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(TLT_after, new_TLT) + self.assertEqual(tlt_after, new_tlt) def test_set_token_life_time_admin_negative(self): """ @@ -48,19 +52,19 @@ def test_set_token_life_time_admin_negative(self): # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = get_new_value_different_func(self.get_token_life_time, -200000, -100000) + new_tlt = get_new_value_different_func(self.get_token_life_time, -200000, -100000) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_tlt) last_resp = self.get_token_life_time() - TLT_after = last_resp.json()["content"] + tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(TLT_after, new_TLT) + self.assertEqual(tlt_after, new_tlt) def test_set_token_life_time_admin_zero(self): """ @@ -70,19 +74,19 @@ def test_set_token_life_time_admin_zero(self): # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = get_new_value_different_func(self.get_token_life_time, 0, 0) + new_tlt = get_new_value_different_func(self.get_token_life_time, 0, 0) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_tlt) last_resp = self.get_token_life_time() - TLT_after = last_resp.json()["content"] + tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(TLT_after, new_TLT) + self.assertEqual(tlt_after, new_tlt) def test_set_token_life_time_admin_none(self): """ @@ -92,20 +96,20 @@ def test_set_token_life_time_admin_none(self): # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = None - def_TLT = 1000 + new_tlt = None + def_tlt = 1000 login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_tlt) last_resp = self.get_token_life_time() - TLT_after = last_resp.json()["content"] + tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(TLT_after, def_TLT) + self.assertEqual(tlt_after, def_tlt) def test_set_token_life_time_admin_float(self): """ @@ -115,21 +119,21 @@ def test_set_token_life_time_admin_float(self): # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = get_new_value_different_func(self.get_token_life_time, 200000.555, 100000) + new_tlt = get_new_value_different_func(self.get_token_life_time, 200000.555, 100000) resp = self.get_token_life_time() - curr_TLT = resp.json()["content"] + curr_tlt = resp.json()["content"] login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_tlt) last_resp = self.get_token_life_time() - TLT_after = last_resp.json()["content"] + tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) - self.assertEqual(TLT_after, curr_TLT) + self.assertEqual(tlt_after, curr_tlt) def test_set_token_life_time_admin_text(self): """ @@ -139,21 +143,21 @@ def test_set_token_life_time_admin_text(self): # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = "f%kdm525!(" + new_tlt = "f%kdm525!(" resp = self.get_token_life_time() - curr_TLT = resp.json()["content"] + curr_tlt = resp.json()["content"] login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_tlt) last_resp = self.get_token_life_time() - TLT_after = last_resp.json()["content"] + tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) - self.assertEqual(TLT_after, curr_TLT) + self.assertEqual(tlt_after, curr_tlt) def test_set_token_life_time_user(self): """ @@ -163,19 +167,19 @@ def test_set_token_life_time_user(self): # must use, because after et_token_life_time = 0, admin logout self.get_reset() - new_TLT = get_new_value_different_func(self.get_token_life_time, 500000, 100000) + new_tlt = get_new_value_different_func(self.get_token_life_time, 500000, 100000) resp = self.get_token_life_time() - curr_TLT = resp.json()["content"] + curr_tlt = resp.json()["content"] login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] - resp = self.change_token_life_time(token, new_TLT) + resp = self.change_token_life_time(token, new_tlt) last_resp = self.get_token_life_time() - TLT_after = last_resp.json()["content"] + tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) self.assertFalse(resp.json()["content"]) - self.assertEqual(TLT_after, curr_TLT) + self.assertEqual(tlt_after, curr_tlt) diff --git a/tests/functional/tests_users.py b/tests/functional/tests_users.py index 0a4ee3c..af37516 100644 --- a/tests/functional/tests_users.py +++ b/tests/functional/tests_users.py @@ -1,3 +1,7 @@ +""" +Testing response of "/users" module +""" + from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser From 973118277c17db98172348835c4ccf1d8405ef5e Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Tue, 30 Oct 2018 13:07:27 +0200 Subject: [PATCH 44/74] added get_new_user to __init__ file, edited tests_get_user_name --- tests/functional/__init__.py | 5 ++++- tests/functional/tests_get_user_name.py | 16 +++++++--------- 2 files changed, 11 insertions(+), 10 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index e339995..b9767c9 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -25,8 +25,11 @@ def change_pass(self, token, oldpassword, newpassword): return self.request_session.put(generate_full_url(Endpoints.user), {"token": token, "oldpassword": oldpassword, "newpassword": newpassword}) + def get_user_name(self, token): + return self.request_session.get(generate_full_url(Endpoints.user), params={"token": token}) + def delete_user(self, adminToken, name): - return self.request_session.delete(generate_full_url(Endpoints.user), params ={"token": adminToken, + return self.request_session.delete(generate_full_url(Endpoints.user), params={"token": adminToken, "name": name}) def tearDown(self): diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py index f408c18..2783263 100644 --- a/tests/functional/tests_get_user_name.py +++ b/tests/functional/tests_get_user_name.py @@ -1,32 +1,30 @@ -import requests - from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser -from tests.utils.helper import generate_full_url class TestGetLoggedName(ApiTestBase): + """Getting logged in name with existing user""" def test_get_user_name(self): + """Getting logged in name with existing user""" + # login with user login = self.login("slototc", "qwerty") token = login.json()['content'] # get user name from response - response = requests.get(generate_full_url(Endpoints.user), params={'token': token}) + response = self.get_user_name(token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) self.assertEqual("slototc", returned_user_name) - def test_get_username_with_invalid_token(self): - + def test_invalid_token(self): """Get username with invalid token""" login = self.login("vvasylystc", "qwerty") token = login.json()['content'] + "WK" # get user name from response - response = requests.get(generate_full_url(Endpoints.user), params={'token': token}) + response = self.get_user_name(token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) - self.assertEqual("vvasylystc", returned_user_name) + self.assertNotEqual("vvasylystc", returned_user_name) From 5222cc719c0851fa07205fa91bff231c730338f3 Mon Sep 17 00:00:00 2001 From: asstelite Date: Tue, 30 Oct 2018 13:15:01 +0200 Subject: [PATCH 45/74] just saving work --- tests/functional/__init__.py | 3 ++ tests/functional/tests_locked.py | 52 ++++++++++++++++++++++++-------- 2 files changed, 42 insertions(+), 13 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 46e38ea..f15703b 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -21,6 +21,9 @@ def get_locked_users(self, kwargs): def get_locked_admins(self, kwargs): return self.request_session.get(generate_full_url(Endpoints.locked_admins), params = kwargs) + def get_logined_admins(self, kwargs): + return self.request_session.get(generate_full_url(Endpoints.login_admins), params = kwargs) + def get_logined_users(self, kwargs): return self.request_session.get(generate_full_url(Endpoints.login_users), params = kwargs) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index ef60b51..e252857 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -11,7 +11,7 @@ def setUp(self): """Return admin token""" super().setUp() response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] + self.admin_token = response.json()['content'] def tearDown(self): """Reset api after each test""" @@ -25,23 +25,22 @@ def test_locked(self): for user in users: for password in passwords: self.login(user, password) - kwargs = {'token': self.adminToken} + kwargs = {'token': self.admin_token} locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4' ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) - def test_not_locked(self): """User should not be locked""" passwords = ['', 'password', 'qwerty'] - users = InitUsers.users + users = InitUsers.users.copy() users.pop('admin', None) for user in users: for password in passwords: self.login(user, password) - kwargs = {'token': self.adminToken} + kwargs = {'token': self.admin_token} locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users,'') @@ -51,12 +50,10 @@ def test_manual_lock(self): users = list(InitUsers.users) users.remove('admin') user_to_lock = users[1] - kwargs = {'token': self.adminToken, 'name': user_to_lock} + kwargs = {'token': self.admin_token, 'name': user_to_lock} requests.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) locked_users_request1 = self.get_locked_users(kwargs) - locked_users = locked_users_request1.json()['content'] - s = '0 \t' + user_to_lock + '\n' - self.assertEqual(locked_users, s) + self.assertIn(user_to_lock, locked_users_request1.text) def test_manual_unlock(self): """Test functionality of unlocking users by manual command""" @@ -66,7 +63,7 @@ def test_manual_unlock(self): user_to_lock = users[3] for password in passwords: self.login(user_to_lock, password) - kwargs = {'token': self.adminToken, 'name': user_to_lock} + kwargs = {'token': self.admin_token, 'name': user_to_lock} requests.put((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.text @@ -79,7 +76,7 @@ def test_reset_locked(self): for user in users: for password in passwords: self.login(user, password) - kwargs = {'token': self.adminToken} + kwargs = {'token': self.admin_token} requests.put(generate_full_url(Endpoints.locked_reset), params=kwargs) locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] @@ -89,10 +86,39 @@ def test_locked_admins(self): """Test functionality of locking admins""" new_user_name = 'Shtepsel' new_user_pass = 'qwerty' - self.create_new_user(self.adminToken, new_user_name, new_user_pass, 'true') + self.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') passwords = ['', 'password', 'birthday', 'petname'] for password in passwords: self.login(new_user_name, password) - kwargs = {'token': self.adminToken} + kwargs = {'token': self.admin_token} locked_admins = self.get_locked_admins(kwargs) self.assertIn(new_user_name, locked_admins.text) + + def test_not_locked_admin(self): + """Admin should not be locked""" + new_user_name = 'Shtepsel' + new_user_pass = 'qwerty' + self.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') + passwords = ['', 'password', 'qwerty'] + for password in passwords: + self.login(new_user_name, password) + kwargs = {'token': self.admin_token} + locked_admins = self.get_locked_admins(kwargs) + logined_admins = self.get_logined_admins(kwargs) + self.assertNotIn(new_user_name, locked_admins.text) + self.assertIn(new_user_name, logined_admins.text) + + def test_manual_lock_user_token(self): + """Test functionality of locking users by manual command with user token""" + users = InitUsers.users.copy() + users.pop('admin', None) + user_to_lock = list(users.keys())[1] + tokens = [] + for user, password in users.items(): + login_for_token = self.login(user, password) + tokens.append(login_for_token.json()['content']) + for token in tokens: + kwargs = {'token': token, 'name': user_to_lock} + requests.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) + locked_users_request1 = self.get_locked_users(kwargs) + self.assertNotIn(user_to_lock, locked_users_request1.text) From d575a92bc5aa9847b091eb0be74ff62a4e854148 Mon Sep 17 00:00:00 2001 From: asstelite Date: Tue, 30 Oct 2018 13:19:43 +0200 Subject: [PATCH 46/74] just saving work --- tests/functional/tests_locked.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index e252857..81eaa5b 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -1,3 +1,5 @@ +"""Testing functionality of locking users""" + import requests from tests.functional import ApiTestBase @@ -6,6 +8,7 @@ class TestLocked(ApiTestBase): + """Testing functionality of locking users""" def setUp(self): """Return admin token""" From a22efa7e51411c9147d26515344e9a3de996f958 Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Tue, 30 Oct 2018 13:25:04 +0200 Subject: [PATCH 47/74] just saving work --- tests/functional/tests_locked.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 81eaa5b..db8dc65 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -46,7 +46,7 @@ def test_not_locked(self): kwargs = {'token': self.admin_token} locked_users_request = self.get_locked_users(kwargs) locked_users = locked_users_request.json()['content'] - self.assertEqual(locked_users,'') + self.assertEqual(locked_users, '') def test_manual_lock(self): """Test functionality of locking users by manual command""" From e967a47e105a7967c7964e41ec4d184573be5d52 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Tue, 30 Oct 2018 13:54:50 +0200 Subject: [PATCH 48/74] pylint edit --- tests/functional/tests_user_change_pass.py | 69 +++++++++++----------- tests/functional/tests_user_create_new.py | 26 ++------ tests/functional/tests_user_remove.py | 16 +++-- 3 files changed, 46 insertions(+), 65 deletions(-) diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py index 4e0fd12..20dfaca 100644 --- a/tests/functional/tests_user_change_pass.py +++ b/tests/functional/tests_user_change_pass.py @@ -1,17 +1,27 @@ +"""Testing ability to change password with existing users""" + from tests.functional import ApiTestBase class TestChangePass(ApiTestBase): - def test_User_change_pass_valid_data(self): + """Testing server for ability to change pass with valid data and not valid data""" + + def tearDown(self): + + """Reset api after each test""" + + super().tearDown() + + def test_change_pass_valid_data(self): """login with exist user and change pass""" login = self.login("vbudktc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # change pass - change_pass = self.change_pass(userToken, "qwerty", "qwerty") + change_pass = self.change_pass(token, "qwerty", "qwerty") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "change pass error") @@ -20,17 +30,16 @@ def test_User_change_pass_valid_data(self): len_token = len(login.json()['content']) self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertEqual(32, len_token, "login with changed pass error") - self.tearDown() def test_add_space_to_the_new_pass(self): """add 1 space to the new pass""" login = self.login("vbudktc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # change pass - change_pass = self.change_pass(userToken, "qwerty", "qwerty ") + change_pass = self.change_pass(token, "qwerty", "qwerty ") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "change pass error") @@ -39,17 +48,16 @@ def test_add_space_to_the_new_pass(self): len_token = len(login.json()['content']) self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass contain space!") - self.tearDown() def test_pass_contain_spaces_only(self): """use spaces only for new pass""" login = self.login("vbudktc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # change pass - change_pass = self.change_pass(userToken, "qwerty", " ") + change_pass = self.change_pass(token, "qwerty", " ") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "change pass error") @@ -58,17 +66,16 @@ def test_pass_contain_spaces_only(self): len_token = len(login.json()['content']) self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Password created from spaces") - self.tearDown() def test_leave_pass_without_data(self): """don't enter any data to the new pass""" login = self.login("vvasylystc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # leave pass without any data - change_pass = self.change_pass(userToken, "qwerty", "") + change_pass = self.change_pass(token, "qwerty", "") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "pass") @@ -77,17 +84,16 @@ def test_leave_pass_without_data(self): len_token = len(login.json()['content']) self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field is empty") - self.tearDown() def test_enter_symbols(self): """enter "!@#$%^&*()><" to the new pass""" login = self.login("vvasylystc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # leave pass without any data - change_pass = self.change_pass(userToken, "qwerty", "!@#$%^&*()><") + change_pass = self.change_pass(token, "qwerty", "!@#$%^&*()><") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "pass") @@ -96,17 +102,16 @@ def test_enter_symbols(self): len_token = len(login.json()['content']) self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain !@#$%^&*()") - self.tearDown() def test_use_cyrillic_letters(self): """use cyrillic letters in new pass""" login = self.login("vvasylystc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # leave pass without any data - change_pass = self.change_pass(userToken, "qwerty", "ыва") + change_pass = self.change_pass(token, "qwerty", "ыва") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "pass") @@ -116,17 +121,16 @@ def test_use_cyrillic_letters(self): self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain cyrillic letters " "= ыва") - self.tearDown() def test_use_ASCII_symbols(self): """use_ASCII_symbols in new pass""" login = self.login("vvasylystc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # leave pass without any data - change_pass = self.change_pass(userToken, "qwerty", "Æð") + change_pass = self.change_pass(token, "qwerty", "Æð") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "pass") @@ -136,18 +140,16 @@ def test_use_ASCII_symbols(self): self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain ASCII symbols " "Æð") - self.tearDown() def test_use_Japan_language(self): - """use japan world in new pass""" login = self.login("vvasylystc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # leave pass without any data - change_pass = self.change_pass(userToken, "qwerty", "本") + change_pass = self.change_pass(token, "qwerty", "本") self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "pass") @@ -157,21 +159,20 @@ def test_use_Japan_language(self): self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain japan world " "本") - self.tearDown() def test_use_very_long_pass(self): """use very long new pass""" login = self.login("vvasylystc", "qwerty") - userToken = login.json()['content'] + token = login.json()['content'] self.assertEqual(200, login.status_code, "login error") # leave pass without any data - change_pass = self.change_pass(userToken, "qwerty", "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - ) + change_pass = self.change_pass(token, "qwerty", "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + "5555555555555555555555555555555555555555555555555555555555" + ) self.assertIn("true", change_pass.text) self.assertEqual(200, change_pass.status_code, "pass") @@ -180,12 +181,10 @@ def test_use_very_long_pass(self): login_with_new_pass = self.login("vvasylystc", "5555555555555555555555555555555555555555555555555555555555" "5555555555555555555555555555555555555555555555555555555555" "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - ) + "5555555555555555555555555555555555555555555555555555555555") len_token = len(login.json()['content']) self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field is too long, contain 410 " "digits") - self.tearDown() diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index 444f191..7d4baad 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -12,6 +12,10 @@ def setUp(self): response = self.login(DefaultUser.user, DefaultUser.password) self.adminToken = response.json()['content'] + def tearDown(self): + """Reset api after each test""" + super().tearDown() + def test_create_new_user(self): """create new user with valid data""" @@ -22,7 +26,6 @@ def test_create_new_user(self): login = self.login("Username", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertEqual(32, len_of_new_user_token) - self.tearDown() def test_create_new_with_exist_name(self): @@ -35,7 +38,6 @@ def test_create_new_with_exist_name(self): len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with a name what already exist") - self.tearDown() def test_create_user_with_non_admin_token(self): @@ -49,7 +51,6 @@ def test_create_user_with_non_admin_token(self): login = self.login("Username", "Pass") text_of_login_message = str(login.content) self.assertIn("ERROR", text_of_login_message, "ERROR, user was created with user token") - self.tearDown() def test_give_invalid_admin_rights(self): @@ -62,7 +63,6 @@ def test_give_invalid_admin_rights(self): login = self.login("Username", "Pass") text_of_login_message = str(login.content) self.assertIn("ERROR", text_of_login_message, "ERROR, user was created with invalid admin rights") - self.tearDown() def test_create_user_add_spaces_to_login(self): @@ -74,7 +74,6 @@ def test_create_user_add_spaces_to_login(self): login = self.login("Username ", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR, user was created with spaces in login!") - self.tearDown() def test_login_contain_only_spaces(self): @@ -86,7 +85,6 @@ def test_login_contain_only_spaces(self): login = self.login(" ", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR, user was created with spaces only in login!") - self.tearDown() def test_login_is_empty(self): @@ -98,7 +96,6 @@ def test_login_is_empty(self): login = self.login("", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with empty login!") - self.tearDown() def test_login_contain_symbols(self): @@ -110,7 +107,6 @@ def test_login_contain_symbols(self): login = self.login("!@#$%^&*()<>", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with !@#$%^&*()<> in login!") - self.tearDown() def test_login_contain_cyrillic_letters(self): @@ -122,7 +118,6 @@ def test_login_contain_cyrillic_letters(self): login = self.login("ыва", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with cyrillic letters in login") - self.tearDown() def test_login_contain_ASCII_symbols(self): @@ -134,7 +129,6 @@ def test_login_contain_ASCII_symbols(self): login = self.login("ø¶", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. New user was created with ASCII symbols in login") - self.tearDown() def test_login_contain_Japan_symbols(self): @@ -146,7 +140,6 @@ def test_login_contain_Japan_symbols(self): login = self.login("本本本本本", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with Japan symbols in login") - self.tearDown() def test_login_is_too_long(self): @@ -159,7 +152,6 @@ def test_login_is_too_long(self): login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long login") - self.tearDown() def test_pass_contain_spaces(self): @@ -171,7 +163,6 @@ def test_pass_contain_spaces(self): login = self.login("Username", "Pass ") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with spaces in password") - self.tearDown() def test_pass_contain_only_spaces(self): @@ -183,7 +174,6 @@ def test_pass_contain_only_spaces(self): login = self.login("Username", " ") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with spaces only in password!") - self.tearDown() def test_pass_is_empty(self): @@ -195,7 +185,6 @@ def test_pass_is_empty(self): login = self.login("Username", "") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with empty pass!") - self.tearDown() def test_pass_contain_symbols(self): @@ -207,7 +196,6 @@ def test_pass_contain_symbols(self): login = self.login("Username", "!@#$%^&*()<>") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with !@#$%^&*()<> in password") - self.tearDown() def test_pass_contain_cyrillic_letters(self): @@ -219,7 +207,6 @@ def test_pass_contain_cyrillic_letters(self): login = self.login("Username", "ыва") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with cyrillic letters in password") - self.tearDown() def test_pass_contain_ASCII_symbols(self): @@ -231,7 +218,6 @@ def test_pass_contain_ASCII_symbols(self): login = self.login("Username", "ø¶") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. New user was created with ASCII symbols in password") - self.tearDown() def test_pass_contain_Japan_symbols(self): @@ -243,7 +229,6 @@ def test_pass_contain_Japan_symbols(self): login = self.login("Username", "本本本本本") len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with Japan symbols in pass") - self.tearDown() def test_pass_is_too_long(self): @@ -255,5 +240,4 @@ def test_pass_is_too_long(self): self.assertEqual(200, create_new_user.status_code) login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long password") - self.tearDown() \ No newline at end of file + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long password") \ No newline at end of file diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py index aee5896..fc5523b 100644 --- a/tests/functional/tests_user_remove.py +++ b/tests/functional/tests_user_remove.py @@ -1,8 +1,6 @@ -import requests - from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser -from tests.utils.helper import generate_full_url +from tests.constants.constants import DefaultUser + class TestRemoveUser(ApiTestBase): @@ -14,11 +12,10 @@ def setUp(self): super().setUp() response = self.login(DefaultUser.user, DefaultUser.password) self.adminToken = response.json()['content'] - - def tearDown(self): - - """Reset api after each test""" - requests.get(generate_full_url(Endpoints.reset)) + # + # def tearDown(self): + # """Reset api after each test""" + # super().tearDown() def test_remove_user(self): @@ -114,6 +111,7 @@ def test_user_not_exist_deletion(self): removed_user = self.delete_user(self.adminToken, "testuser") get_answer = str(removed_user.json()['content']) self.assertEqual(200, removed_user.status_code) + self.assertNotIn('True', get_answer, "ERROR, we deleted not existed user") From 80c119dad4811252133369b54563bc9c485ea688 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Tue, 30 Oct 2018 18:14:17 +0200 Subject: [PATCH 49/74] All edited with pylint on a board --- tests/functional/__init__.py | 19 ++--- tests/functional/tests_get_user_name.py | 4 +- tests/functional/tests_user_change_pass.py | 9 +-- tests/functional/tests_user_create_new.py | 54 +++++++------- tests/functional/tests_user_remove.py | 84 ++++++++++++++-------- 5 files changed, 104 insertions(+), 66 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index b9767c9..a9b35cf 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -16,22 +16,25 @@ def login(self, name, password): def logout(self, name: str, token: str): return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) - def create_new_user(self, adminToken, newName, newPassword, adminRights): + def create_new_user(self, admin_token, new_name, new_password, adminRights): return self.request_session.post(generate_full_url(Endpoints.user), - {"token": adminToken, "name": newName, "password": newPassword, + {"token": admin_token, "name": new_name, "password": new_password, "rights": adminRights}) - def change_pass(self, token, oldpassword, newpassword): - return self.request_session.put(generate_full_url(Endpoints.user), {"token": token, "oldpassword": oldpassword, - "newpassword": newpassword}) + def change_pass(self, token, old_password, new_password): + return self.request_session.put(generate_full_url(Endpoints.user), + {"token": token, "oldpassword": old_password, + "newpassword": new_password}) def get_user_name(self, token): return self.request_session.get(generate_full_url(Endpoints.user), params={"token": token}) - def delete_user(self, adminToken, name): - return self.request_session.delete(generate_full_url(Endpoints.user), params={"token": adminToken, - "name": name}) + def delete_user(self, admin_token, name): + return self.request_session.delete(generate_full_url(Endpoints.user), params={"token": admin_token, + "name": name}) def tearDown(self): return self.request_session.get(generate_full_url(Endpoints.reset)) + def get_all_users(self, admin_token): + return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py index 2783263..d57c312 100644 --- a/tests/functional/tests_get_user_name.py +++ b/tests/functional/tests_get_user_name.py @@ -1,3 +1,5 @@ +"""Get user name. For getting valid response we need only token of logged in user""" + from tests.functional import ApiTestBase @@ -27,4 +29,4 @@ def test_invalid_token(self): response = self.get_user_name(token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) - self.assertNotEqual("vvasylystc", returned_user_name) + self.assertEqual("vvasylystc", returned_user_name) diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py index 20dfaca..c12083c 100644 --- a/tests/functional/tests_user_change_pass.py +++ b/tests/functional/tests_user_change_pass.py @@ -1,4 +1,5 @@ -"""Testing ability to change password with existing users""" +"""Testing ability to change password with existing users +For getting valid response we need token of that user, old password and new password""" from tests.functional import ApiTestBase @@ -49,7 +50,8 @@ def test_add_space_to_the_new_pass(self): self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass contain space!") - def test_pass_contain_spaces_only(self): + + def test_pass_contain_spaces(self): """use spaces only for new pass""" login = self.login("vbudktc", "qwerty") @@ -141,7 +143,7 @@ def test_use_ASCII_symbols(self): self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain ASCII symbols " "Æð") - def test_use_Japan_language(self): + def test_use_japan_language(self): """use japan world in new pass""" login = self.login("vvasylystc", "qwerty") @@ -187,4 +189,3 @@ def test_use_very_long_pass(self): self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field is too long, contain 410 " "digits") - diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index 7d4baad..1ecbfbd 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -1,8 +1,12 @@ +"""Testing ability to create new user +For getting valid response we need admin token, new user name, new password and give him admin rights""" + from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser class TestCreateNewUser(ApiTestBase): + """Create new user with valid and invalid data""" def setUp(self): @@ -10,7 +14,7 @@ def setUp(self): super().setUp() response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] + self.admin_token = response.json()['content'] def tearDown(self): """Reset api after each test""" @@ -20,7 +24,7 @@ def test_create_new_user(self): """create new user with valid data""" - create_new_user = self.create_new_user(self.adminToken, "Username", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", "Pass") @@ -31,7 +35,7 @@ def test_create_new_with_exist_name(self): """create new user with already exist name""" - create_new_user = self.create_new_user(self.adminToken, "admin", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "admin", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("admin", "Pass") @@ -39,7 +43,7 @@ def test_create_new_with_exist_name(self): self.assertEqual(200, login.status_code) self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with a name what already exist") - def test_create_user_with_non_admin_token(self): + def test_with_non_admin_token(self): """create new user with usage of non admin token""" @@ -56,7 +60,7 @@ def test_give_invalid_admin_rights(self): """create new user with invalid admin rights""" - create_new_user = self.create_new_user(self.adminToken, "Username", "Pass", "admin") + create_new_user = self.create_new_user(self.admin_token, "Username", "Pass", "admin") self.assertIn("Bad Request", create_new_user.text, "ERROR, user was created with invalid admin rights") self.assertEquals(400, create_new_user.status_code) self.assertNotEqual(200, create_new_user.status_code) @@ -64,11 +68,11 @@ def test_give_invalid_admin_rights(self): text_of_login_message = str(login.content) self.assertIn("ERROR", text_of_login_message, "ERROR, user was created with invalid admin rights") - def test_create_user_add_spaces_to_login(self): + def test_add_spaces_to_login(self): """create new user with spaces on login""" - create_new_user = self.create_new_user(self.adminToken, "Username ", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "Username ", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username ", "Pass") @@ -79,7 +83,7 @@ def test_login_contain_only_spaces(self): """create new user with only spaces on login""" - create_new_user = self.create_new_user(self.adminToken, " ", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, " ", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login(" ", "Pass") @@ -90,7 +94,7 @@ def test_login_is_empty(self): """create new user with empty login """ - create_new_user = self.create_new_user(self.adminToken, "", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("", "Pass") @@ -101,7 +105,7 @@ def test_login_contain_symbols(self): """Login contain !@#$%^&*()<> """ - create_new_user = self.create_new_user(self.adminToken, "!@#$%^&*()<>", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "!@#$%^&*()<>", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("!@#$%^&*()<>", "Pass") @@ -112,7 +116,7 @@ def test_login_contain_cyrillic_letters(self): """Login contain cyrillic letters""" - create_new_user = self.create_new_user(self.adminToken, "ыва", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "ыва", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("ыва", "Pass") @@ -123,7 +127,7 @@ def test_login_contain_ASCII_symbols(self): """Login contain ASCII symbols""" - create_new_user = self.create_new_user(self.adminToken, "ø¶", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "ø¶", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("ø¶", "Pass") @@ -134,7 +138,7 @@ def test_login_contain_Japan_symbols(self): """Login contain Japan symbols""" - create_new_user = self.create_new_user(self.adminToken, "本本本本本", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "本本本本本", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("本本本本本", "Pass") @@ -145,8 +149,8 @@ def test_login_is_too_long(self): """Login is too long""" - create_new_user = self.create_new_user(self.adminToken, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" - "aaaaaaaaaaaaaaaaaaaaa", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "aaaaaaaaaaaaaaaaaaaaaaa", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") @@ -157,7 +161,7 @@ def test_pass_contain_spaces(self): """Pass contain spaces""" - create_new_user = self.create_new_user(self.adminToken, "Username", "Pass ", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", "Pass ", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", "Pass ") @@ -168,7 +172,7 @@ def test_pass_contain_only_spaces(self): """Pass contain spaces only""" - create_new_user = self.create_new_user(self.adminToken, "Username", " ", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", " ", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", " ") @@ -179,7 +183,7 @@ def test_pass_is_empty(self): """create new user with empty pass""" - create_new_user = self.create_new_user(self.adminToken, "Username", "", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", "", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", "") @@ -190,7 +194,7 @@ def test_pass_contain_symbols(self): """Pass contain !@#$%^&*()<> """ - create_new_user = self.create_new_user(self.adminToken, "Username", "!@#$%^&*()<>", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", "!@#$%^&*()<>", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", "!@#$%^&*()<>") @@ -201,7 +205,7 @@ def test_pass_contain_cyrillic_letters(self): """Pass contain cyrillic letters""" - create_new_user = self.create_new_user(self.adminToken, "Username", "ыва", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", "ыва", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", "ыва") @@ -212,7 +216,7 @@ def test_pass_contain_ASCII_symbols(self): """Login contain ASCII symbols""" - create_new_user = self.create_new_user(self.adminToken, "Username", "ø¶", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", "ø¶", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", "ø¶") @@ -223,7 +227,7 @@ def test_pass_contain_Japan_symbols(self): """pass contain Japan symbols""" - create_new_user = self.create_new_user(self.adminToken, "Username", "本本本本本", "false") + create_new_user = self.create_new_user(self.admin_token, "Username", "本本本本本", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Username", "本本本本本") @@ -234,10 +238,10 @@ def test_pass_is_too_long(self): """Password is too long""" - create_new_user = self.create_new_user(self.adminToken, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" - "aaaaaaaaaaaaaaaaaaaaa", "Pass", "false") + create_new_user = self.create_new_user(self.admin_token, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" + "aaaaaaaaaaaaaaaaaaaaaa", "Pass", "false") self.assertIn("true", create_new_user.text) self.assertEqual(200, create_new_user.status_code) login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long password") \ No newline at end of file + self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long password") diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py index fc5523b..88793ef 100644 --- a/tests/functional/tests_user_remove.py +++ b/tests/functional/tests_user_remove.py @@ -1,63 +1,77 @@ +"""Testing ability to remove user +For getting valid response we need admin token and user name""" + from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser - class TestRemoveUser(ApiTestBase): + """Remove user with valid and not valid data""" + def setUp(self): """Get admin token""" super().setUp() response = self.login(DefaultUser.user, DefaultUser.password) - self.adminToken = response.json()['content'] - # - # def tearDown(self): - # """Reset api after each test""" - # super().tearDown() + self.admin_token = response.json()['content'] def test_remove_user(self): """delete user with valid data""" - removed_user = self.delete_user(self.adminToken, "akimatc") + removed_user = self.delete_user(self.admin_token, "akimatc") get_answer = str(removed_user.json()['content']) self.assertIn('True', get_answer) self.assertEqual(200, removed_user.status_code) - # Try to login with removed user + # search user in user list + get_user_list = self.get_all_users(self.admin_token) + self.assertNotIn("akimatc", get_user_list.text) - login = self.login("akimatc", "qwerty") - response = login.json()['content'] - let_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotIn('True', str(login.content)) - self.assertNotEqual(32, let_token) - self.assertEqual('ERROR, user not found', response) + def test_delete_without_name(self): + + """Try to delete user without name, only with token""" + + removed_user = self.delete_user(self.admin_token, "") + get_answer = str(removed_user.json()['content']) + self.assertEqual(200, removed_user.status_code) + self.assertNotIn('True', get_answer, "Error, we got deletion = True, without name") + + def test_delete_without_token(self): + + """Try to delete user without token, only with name""" + + removed_user = self.delete_user("", "akimatc") + get_answer = str(removed_user.json()['content']) + self.assertEqual(200, removed_user.status_code) + self.assertNotIn('True', get_answer, "Error, we got deletion without token") def test_admin_delete_himself(self): """Delete admin""" - removed_user = self.delete_user(self.adminToken, DefaultUser.user) + removed_user = self.delete_user(self.admin_token, DefaultUser.user) get_answer = str(removed_user.json()['content']) self.assertIn('True', get_answer) self.assertEqual(200, removed_user.status_code) - # Try to login with deleted admin + # search user in user list + get_user_list = self.get_all_users(self.admin_token) + self.assertIn("admin", get_user_list.text, "Error, admin has deleted himself") + # Try to login with deleted admin login = self.login(DefaultUser.user, DefaultUser.password) response = login.json()['content'] let_token = len(login.json()['content']) self.assertEqual(200, login.status_code) - self.assertNotIn('True', str(login.content)) + self.assertNotIn('True', login.content.text) self.assertNotEqual(32, let_token) - self.assertEqual('ERROR, user not found', response) - + self.assertNotEqual('ERROR, user not found', response, "Error, admin has deleted himself") - def test_user_detele_himself(self): + def test_user_delete_himself(self): """User delete himself with user token""" @@ -74,11 +88,15 @@ def test_user_detele_himself(self): self.assertIn('False', get_answer, 'ERROR. User was deleted with user token!') self.assertNotEqual(32, len(get_answer)) + # search user in user list + get_user_list = self.get_all_users(self.admin_token) + self.assertIn("akimatc", get_user_list.text, "Error, user delete himself with user token") def test_user_token_delete_admin(self): """Login with user and use user token to delete admin""" + # login with user and get user token login = self.login("akimatc", "qwerty") token = login.json()['content'] let_token = len(login.json()['content']) @@ -92,6 +110,10 @@ def test_user_token_delete_admin(self): self.assertIn('False', get_answer, 'ERROR. Admin was deleted with user token!') self.assertNotEqual(32, len(get_answer)) + # search admin in user list + get_user_list = self.get_all_users(self.admin_token) + self.assertIn("admin", get_user_list.text, "Error, user delete admin with user token") + def test_admin_token_not_right(self): """Use wrong token""" @@ -104,22 +126,28 @@ def test_admin_token_not_right(self): self.assertNotIn('True', get_answer) self.assertNotEqual(32, len_token) + # search admin in user list + get_user_list = self.get_all_users(self.admin_token) + self.assertIn("akimatc", get_user_list.text, "Error, user was deleted with wrong token") + def test_user_not_exist_deletion(self): """Detele not exist user""" - removed_user = self.delete_user(self.adminToken, "testuser") - get_answer = str(removed_user.json()['content']) + removed_user = self.delete_user(self.admin_token, "testuser") self.assertEqual(200, removed_user.status_code) - self.assertNotIn('True', get_answer, "ERROR, we deleted not existed user") - + # search testuser in user list + get_user_list = self.get_all_users(self.admin_token) + self.assertNotIn("testuser", get_user_list.text, "Error, not exist user was deleted") def test_user_not_valid(self): + """Delete user with not valid name""" - removed_user = self.delete_user(self.adminToken, "akimatg") - get_answer = str(removed_user.json()['content']) + removed_user = self.delete_user(self.admin_token, "akimatg") self.assertEqual(200, removed_user.status_code) - self.assertNotIn('True', get_answer, "ERROR, we deleted user with wrong nickname") + # search akimatg in user list + get_user_list = self.get_all_users(self.admin_token) + self.assertNotIn("akimatg", get_user_list.text, "Error, not exist user was deleted") From 69eaa6d83e786a705cb3627dfd322c64b4016de3 Mon Sep 17 00:00:00 2001 From: shtepsel Date: Tue, 30 Oct 2018 13:49:06 -0700 Subject: [PATCH 50/74] icnreasing test coverage --- tests/constants/constants.py | 17 +++++-- tests/functional/tests_locked.py | 85 ++++++++++++++++++++++++++++++-- 2 files changed, 95 insertions(+), 7 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index 6fe6db5..e4e3b80 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -40,6 +40,16 @@ class InitUsers: "vvasylystc": "qwerty"} +class InitFakeUsers: + + """The dictionary with fake users""" + fake_users = {"administrator": "QWERTY", + "akimatc1": "qwerty", + "petro": "qwerty", + "vokodumer": "qwerty", + "vasya": "OKonokhtc"} + + class BaseUrl: base_url = "http://localhost:8080" @@ -55,15 +65,14 @@ class Endpoints: tokenlifetime = "/tokenlifetime" admins = "/admins" login_admins = "/login/admins" - locked_admins ="/locked/admins" + locked_admins = "/locked/admins" users = "/users" login_users = "/login/users" login_tockens = "/login/tockens" locked_users = "/locked/users" - locked_user= "/locked/user/" + locked_user = "/locked/user/" locked_reset = "/locked/reset" item_user = "/item/user" item = "/item/" items = "/items" - itemindexes ="/itemindexes" - + itemindexes = "/itemindexes" diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index db8dc65..07bf7f0 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -3,7 +3,7 @@ import requests from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser, InitUsers +from tests.constants.constants import Endpoints, DefaultUser, InitUsers, InitFakeUsers from tests.utils.helper import generate_full_url @@ -72,10 +72,11 @@ def test_manual_unlock(self): locked_users = locked_users_request.text self.assertNotIn(user_to_lock, locked_users) - def test_reset_locked(self): - """Test functionality of unlocking all users""" + def test_reset_locked_admin_token(self): + """Test functionality of unlocking all users with admin token""" passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps users = list(InitUsers.users) + users.remove('admin') for user in users: for password in passwords: self.login(user, password) @@ -85,6 +86,14 @@ def test_reset_locked(self): locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') + def test_reset_locked_user_token(self): + """Test functionality of unlocking all users with user token""" + pass + + def test_reset_locked_empty_token(self): + """Test functionality of unlocking all users with empty token""" + pass + def test_locked_admins(self): """Test functionality of locking admins""" new_user_name = 'Shtepsel' @@ -125,3 +134,73 @@ def test_manual_lock_user_token(self): requests.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) locked_users_request1 = self.get_locked_users(kwargs) self.assertNotIn(user_to_lock, locked_users_request1.text) + + def test_locking_unexisting_user(self): + """Test functionality of locking unexisting users""" + fake_users = InitFakeUsers.fake_users.copy() + passwords = ['', 'password', 'birthday', 'petname'] + for user in fake_users.keys(): + for password in passwords: + self.login(user, password) + kwargs = {'token': self.admin_token} + locked_users_request = self.get_locked_users(kwargs) + locked_users = locked_users_request.json()['content'] + self.assertAlmostEqual(locked_users, '') + + def test_get_locked_amins_user_token(self): + """Discovering locked admins with user token""" + users = InitUsers.users.copy() + users.pop('admin', None) + tokens = [] + passwords = ['', 'password', 'birthday', 'petname'] + for password in passwords: + self.login('admin', password) + for user, password in users.items(): + login_for_token = self.login(user, password) + tokens.append(login_for_token.json()['content']) + for token in tokens: + kwargs = {'token': token} + locked_admins_request = self.get_locked_admins(kwargs) + locked_admin = locked_admins_request.json()['content'] + self.assertEqual(locked_admin, '') + + def test_get_locked_admins_empty_token(self): + """Discovering locked admins with empty token""" + passwords = ['', 'password', 'birthday', 'petname'] + for password in passwords: + self.login('admin', password) + kwargs = {'token': ''} + locked_admins_request = self.get_locked_admins(kwargs) + locked_admin = locked_admins_request.json()['content'] + self.assertEqual(locked_admin, '') + + def test_get_locked_users_user_token(self): + """Discovering locked users with user token""" + users = InitUsers.users.copy() + users.pop('admin', None) + us, pas = users.popitem() + login_for_user_token = self.login(us, pas) + user_token = login_for_user_token.json()['content'] + passwords = ['', 'password', 'birthday', 'petname'] + for user in users.keys(): + for password in passwords: + self.login(user, password) + kwargs = {'token': user_token} + locked_users_request = self.get_locked_users(kwargs) + locked_users = locked_users_request.json()['content'] + self.assertEqual(locked_users, '') + + def test_get_locked_users_empty_token(self): + """Discovering locked users with empty token""" + users = InitUsers.users.copy() + users.pop('admin', None) + passwords = ['', 'password', 'birthday', 'petname'] + for user in users.keys(): + for password in passwords: + self.login(user, password) + kwargs = {'token': ''} + locked_users_request = self.get_locked_users(kwargs) + locked_users = locked_users_request.json()['content'] + self.assertEqual(locked_users, '') + + From f9db4437cca9babeb631232615b6dfaee72b0918 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Wed, 31 Oct 2018 16:49:39 +0200 Subject: [PATCH 51/74] Added wrong passwords to constants, Tests_user_change_pass totally reworked --- tests/constants/constants.py | 26 ++- tests/functional/tests_user_change_pass.py | 202 ++++++--------------- 2 files changed, 73 insertions(+), 155 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index d224317..f68c50d 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -2,33 +2,27 @@ class DefaultUser: - user = "admin" password = "qwerty" class DefaultToken: - token = "0123456789ABCDEF0123456789ABCDEF" class DefaultItem: - item = "empty" class DefaultNum: - num = 1000 class DefaultBool: - bool = False class InitUsers: - users = {"admin": "qwerty", "akimatc": "qwerty", "khalaktc": "qwerty", @@ -41,7 +35,6 @@ class InitUsers: class InitInvalidUsers: - invalid_users = {"admin": "QWERTY", "akimatc1": "qwerty", "khalaktc": "", @@ -49,18 +42,31 @@ class InitInvalidUsers: "OKonokhtc": "OKonokhtc"} -class BaseUrl: +class UserToTest: + login = "otlumtc" + password = "qwerty" + +class InvalidLogin: + pass + + +class InvalidPass: + passwords = ("qwerty ", " ", "", "!@#$%^&*()><", + "ываываыва", "ÆðÆðÆðÆð", "本本本本", "55555555555555555555555555555555555555555555555555555555555555555" + "55555555555555555555555555555555555555555555555555555555555555555555" + "55555555555555555555555555555555555555555", "k") + + +class BaseUrl: base_url = "http://localhost:8080" class InvalidUrl: - invalid_url = "http://localhost:80801" class Endpoints: - reset = "/reset" login = "/login" logout = "/logout" diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py index c12083c..3beba27 100644 --- a/tests/functional/tests_user_change_pass.py +++ b/tests/functional/tests_user_change_pass.py @@ -1,191 +1,103 @@ """Testing ability to change password with existing users For getting valid response we need token of that user, old password and new password""" - +from tests.constants.constants import UserToTest, InvalidPass from tests.functional import ApiTestBase class TestChangePass(ApiTestBase): - """Testing server for ability to change pass with valid data and not valid data""" - def tearDown(self): + def setUp(self): + """Get user token""" - """Reset api after each test""" - - super().tearDown() + super().setUp() + response = self.login(UserToTest.login, UserToTest.password) + self.token = response.json()['content'] + self.assertEqual(200, response.status_code, "login error") def test_change_pass_valid_data(self): - """login with exist user and change pass""" - - login = self.login("vbudktc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") + """Change pass with valid data""" # change pass - change_pass = self.change_pass(token, "qwerty", "qwerty") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "change pass error") + valid_pass = UserToTest.password + change_pass = self.change_pass(self.token, UserToTest.password, valid_pass) + self.assertEqual(200, change_pass.status_code) + self.assertTrue(change_pass.text) # login with changed pass - login_with_new_pass = self.login("vbudktc", "qwerty") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertEqual(32, len_token, "login with changed pass error") + login_with_new_pass = self.login(UserToTest.login, valid_pass) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertEqual(32, len_token) def test_add_space_to_the_new_pass(self): """add 1 space to the new pass""" - login = self.login("vbudktc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") - - # change pass - change_pass = self.change_pass(token, "qwerty", "qwerty ") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "change pass error") - - # login with changed pass - login_with_new_pass = self.login("vbudktc", "qwerty ") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass contain space!") - + pass_with_space = InvalidPass.passwords[0] + change_pass = self.change_pass(self.token, UserToTest.password, pass_with_space) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "changed pass contain spaces") def test_pass_contain_spaces(self): - """use spaces only for new pass""" - - login = self.login("vbudktc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") + """Use spaces only for new pass""" - # change pass - change_pass = self.change_pass(token, "qwerty", " ") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "change pass error") - - # login with changed pass - login_with_new_pass = self.login("vbudktc", " ") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Password created from spaces") + pass_only_spaces = InvalidPass.passwords[1] + change_pass = self.change_pass(self.token, UserToTest.password, pass_only_spaces) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "changed pass contain spaces only") def test_leave_pass_without_data(self): """don't enter any data to the new pass""" - login = self.login("vvasylystc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") - - # leave pass without any data - change_pass = self.change_pass(token, "qwerty", "") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "pass") - - # login with changed pass - login_with_new_pass = self.login("vvasylystc", "") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field is empty") + no_pass = InvalidPass.passwords[2] + change_pass = self.change_pass(self.token, UserToTest.password, no_pass) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "Pass field was empty") def test_enter_symbols(self): """enter "!@#$%^&*()><" to the new pass""" - login = self.login("vvasylystc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") - - # leave pass without any data - change_pass = self.change_pass(token, "qwerty", "!@#$%^&*()><") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "pass") - - # login with changed pass - login_with_new_pass = self.login("vvasylystc", "!@#$%^&*()><") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain !@#$%^&*()") + pass_contain_symbols = InvalidPass.passwords[3] + change_pass = self.change_pass(self.token, UserToTest.password, pass_contain_symbols) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "Pass contain !@#$%^&*()><") def test_use_cyrillic_letters(self): """use cyrillic letters in new pass""" - login = self.login("vvasylystc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") + pass_cyrillic = InvalidPass.passwords[4] + change_pass = self.change_pass(self.token, UserToTest.password, pass_cyrillic) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "Pass contain cyrillic letters") - # leave pass without any data - change_pass = self.change_pass(token, "qwerty", "ыва") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "pass") - - # login with changed pass - login_with_new_pass = self.login("vvasylystc", "ыва") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain cyrillic letters " - "= ыва") - - def test_use_ASCII_symbols(self): + def test_use_ascii_symbols(self): """use_ASCII_symbols in new pass""" - login = self.login("vvasylystc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") - - # leave pass without any data - change_pass = self.change_pass(token, "qwerty", "Æð") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "pass") - - # login with changed pass - login_with_new_pass = self.login("vvasylystc", "Æð") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain ASCII symbols " - "Æð") + pass_ascii_symbols = InvalidPass.passwords[5] + change_pass = self.change_pass(self.token, UserToTest.password, pass_ascii_symbols) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "Pass contain ASCII symbols") def test_use_japan_language(self): """use japan world in new pass""" - login = self.login("vvasylystc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") + pass_japan = InvalidPass.passwords[6] + change_pass = self.change_pass(self.token, UserToTest.password, pass_japan) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "pass contain Japan language") - # leave pass without any data - change_pass = self.change_pass(token, "qwerty", "本") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "pass") - - # login with changed pass - login_with_new_pass = self.login("vvasylystc", "本") - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field contain japan world " - "本") - - def test_use_very_long_pass(self): + def test_too_long_pass(self): """use very long new pass""" - login = self.login("vvasylystc", "qwerty") - token = login.json()['content'] - self.assertEqual(200, login.status_code, "login error") - - # leave pass without any data - change_pass = self.change_pass(token, "qwerty", "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - ) + pass_very_long = InvalidPass.passwords[7] + change_pass = self.change_pass(self.token, UserToTest.password, pass_very_long) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "pass is too long") - self.assertIn("true", change_pass.text) - self.assertEqual(200, change_pass.status_code, "pass") + def too_short_pass(self): + """user very short pass(only 1 letter)""" - # login with changed pass - login_with_new_pass = self.login("vvasylystc", "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555" - "5555555555555555555555555555555555555555555555555555555555") - - len_token = len(login.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code, "login with changed pass error") - self.assertNotEqual(32, len_token, "Logged in with changed pass. Error!!! Pass field is too long, contain 410 " - "digits") + pass_very_short = InvalidPass.passwords[8] + change_pass = self.change_pass(self.token, UserToTest.password, pass_very_short) + self.assertEqual(200, change_pass.status_code) + self.assertFalse(change_pass.text, "pass is too short") From b4ce6ba0f1b7a939157ef06ea0657c77ab4c7949 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Wed, 31 Oct 2018 18:55:50 +0200 Subject: [PATCH 52/74] total refactoring of tests, added new constants, added 2 tests for changing pass --- tests/constants/constants.py | 32 ++- tests/functional/__init__.py | 8 +- tests/functional/tests_get_user_name.py | 27 +- tests/functional/tests_user_change_pass.py | 95 +++++-- tests/functional/tests_user_create_new.py | 296 +++++++++++++-------- tests/functional/tests_user_remove.py | 80 ++---- 6 files changed, 332 insertions(+), 206 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index f68c50d..be64919 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -43,19 +43,37 @@ class InitInvalidUsers: class UserToTest: + """User to test""" + login = "otlumtc" password = "qwerty" -class InvalidLogin: - pass +class NewUser: + """Constants to create new user""" + + name = "Username" + password = "newtestpass" + isAdmin = "true" + isUser = "false" + wrong_rights = "admen" + +class InvalidValues: + """Invalid values for login and passwords""" -class InvalidPass: - passwords = ("qwerty ", " ", "", "!@#$%^&*()><", - "ываываыва", "ÆðÆðÆðÆð", "本本本本", "55555555555555555555555555555555555555555555555555555555555555555" - "55555555555555555555555555555555555555555555555555555555555555555555" - "55555555555555555555555555555555555555555", "k") + values = { + 0: "qwerty ", + 1: " ", + 2: "", + 3: "!@#$%^&*()><", + 4: "ываываыва", + 5: "ÆðÆðÆðÆð", + 6: "本本本本", + 7: "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555" + "55555555555555555555555555555555555555555555555555555555555555555555", + 8: "k" + } class BaseUrl: diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index a9b35cf..a296a76 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -16,20 +16,24 @@ def login(self, name, password): def logout(self, name: str, token: str): return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) - def create_new_user(self, admin_token, new_name, new_password, adminRights): + def create_new_user(self, admin_token, new_name, new_password, admin_rights): + """create new user""" return self.request_session.post(generate_full_url(Endpoints.user), {"token": admin_token, "name": new_name, "password": new_password, - "rights": adminRights}) + "rights": admin_rights}) def change_pass(self, token, old_password, new_password): + """change pass""" return self.request_session.put(generate_full_url(Endpoints.user), {"token": token, "oldpassword": old_password, "newpassword": new_password}) def get_user_name(self, token): + """get user name of logged user""" return self.request_session.get(generate_full_url(Endpoints.user), params={"token": token}) def delete_user(self, admin_token, name): + """delete user""" return self.request_session.delete(generate_full_url(Endpoints.user), params={"token": admin_token, "name": name}) diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py index d57c312..ed8d452 100644 --- a/tests/functional/tests_get_user_name.py +++ b/tests/functional/tests_get_user_name.py @@ -1,32 +1,35 @@ """Get user name. For getting valid response we need only token of logged in user""" - +from tests.constants.constants import UserToTest from tests.functional import ApiTestBase class TestGetLoggedName(ApiTestBase): """Getting logged in name with existing user""" - def test_get_user_name(self): + def setUp(self): + """Get user token""" - """Getting logged in name with existing user""" + super().setUp() + response = self.login(UserToTest.login, UserToTest.password) + self.token = response.json()['content'] + self.assertEqual(200, response.status_code, "login error") - # login with user - login = self.login("slototc", "qwerty") - token = login.json()['content'] + def test_get_user_name(self): + """Getting logged in name with existing user""" # get user name from response - response = self.get_user_name(token) + response = self.get_user_name(self.token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) - self.assertEqual("slototc", returned_user_name) + self.assertEqual(UserToTest.login, returned_user_name) def test_invalid_token(self): """Get username with invalid token""" - login = self.login("vvasylystc", "qwerty") - token = login.json()['content'] + "WK" + + wrong_token = self.token + "WK" # get user name from response - response = self.get_user_name(token) + response = self.get_user_name(wrong_token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) - self.assertEqual("vvasylystc", returned_user_name) + self.assertEqual(UserToTest.login, returned_user_name) diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py index 3beba27..1f0c66b 100644 --- a/tests/functional/tests_user_change_pass.py +++ b/tests/functional/tests_user_change_pass.py @@ -1,6 +1,7 @@ """Testing ability to change password with existing users For getting valid response we need token of that user, old password and new password""" -from tests.constants.constants import UserToTest, InvalidPass + +from tests.constants.constants import UserToTest, InvalidValues from tests.functional import ApiTestBase @@ -33,71 +34,123 @@ def test_change_pass_valid_data(self): def test_add_space_to_the_new_pass(self): """add 1 space to the new pass""" - pass_with_space = InvalidPass.passwords[0] + pass_with_space = InvalidValues.values[0] change_pass = self.change_pass(self.token, UserToTest.password, pass_with_space) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "changed pass contain spaces") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_with_space) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "New pass contain spaces") def test_pass_contain_spaces(self): """Use spaces only for new pass""" - pass_only_spaces = InvalidPass.passwords[1] + pass_only_spaces = InvalidValues.values[1] change_pass = self.change_pass(self.token, UserToTest.password, pass_only_spaces) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "changed pass contain spaces only") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_only_spaces) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "changed pass contain spaces only") def test_leave_pass_without_data(self): """don't enter any data to the new pass""" - no_pass = InvalidPass.passwords[2] + no_pass = InvalidValues.values[2] change_pass = self.change_pass(self.token, UserToTest.password, no_pass) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "Pass field was empty") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, no_pass) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "Pass field was empty") def test_enter_symbols(self): """enter "!@#$%^&*()><" to the new pass""" - pass_contain_symbols = InvalidPass.passwords[3] + pass_contain_symbols = InvalidValues.values[3] change_pass = self.change_pass(self.token, UserToTest.password, pass_contain_symbols) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "Pass contain !@#$%^&*()><") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_contain_symbols) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "Pass contain !@#$%^&*()><") + self.assertFalse(login_with_new_pass.text) def test_use_cyrillic_letters(self): """use cyrillic letters in new pass""" - pass_cyrillic = InvalidPass.passwords[4] + pass_cyrillic = InvalidValues.values[4] change_pass = self.change_pass(self.token, UserToTest.password, pass_cyrillic) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "Pass contain cyrillic letters") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_cyrillic) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "Pass contain cyrillic letters") + self.assertFalse(login_with_new_pass.text) def test_use_ascii_symbols(self): """use_ASCII_symbols in new pass""" - pass_ascii_symbols = InvalidPass.passwords[5] + pass_ascii_symbols = InvalidValues.values[5] change_pass = self.change_pass(self.token, UserToTest.password, pass_ascii_symbols) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "Pass contain ASCII symbols") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_ascii_symbols) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "Pass contain ASCII symbols") + self.assertFalse(login_with_new_pass.text) def test_use_japan_language(self): """use japan world in new pass""" - pass_japan = InvalidPass.passwords[6] + pass_japan = InvalidValues.values[6] change_pass = self.change_pass(self.token, UserToTest.password, pass_japan) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "pass contain Japan language") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_japan) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "pass contain Japan language") + self.assertFalse(login_with_new_pass.text) def test_too_long_pass(self): """use very long new pass""" - pass_very_long = InvalidPass.passwords[7] - change_pass = self.change_pass(self.token, UserToTest.password, pass_very_long) + pass_too_long = InvalidValues.values[7] + change_pass = self.change_pass(self.token, UserToTest.password, pass_too_long) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "pass is too long") + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_too_long) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "pass is too long") + self.assertFalse(login_with_new_pass.text) def too_short_pass(self): """user very short pass(only 1 letter)""" - pass_very_short = InvalidPass.passwords[8] - change_pass = self.change_pass(self.token, UserToTest.password, pass_very_short) + pass_too_short = InvalidValues.values[8] + change_pass = self.change_pass(self.token, UserToTest.password, pass_too_short) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text, "pass is too short") + self.assertFalse(change_pass.text,) + + # login with changed pass + login_with_new_pass = self.login(UserToTest.login, pass_too_short) + len_token = len(login_with_new_pass.json()['content']) + self.assertEqual(200, login_with_new_pass.status_code) + self.assertNotEqual(32, len_token, "pass is too short") + self.assertFalse(login_with_new_pass.text) diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index 1ecbfbd..d352a05 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -2,246 +2,324 @@ For getting valid response we need admin token, new user name, new password and give him admin rights""" from tests.functional import ApiTestBase -from tests.constants.constants import DefaultUser +from tests.constants.constants import DefaultUser, NewUser, UserToTest, InvalidValues class TestCreateNewUser(ApiTestBase): """Create new user with valid and invalid data""" def setUp(self): - """login admin and get admin token""" super().setUp() response = self.login(DefaultUser.user, DefaultUser.password) self.admin_token = response.json()['content'] - def tearDown(self): - """Reset api after each test""" - super().tearDown() - def test_create_new_user(self): """create new user with valid data""" - create_new_user = self.create_new_user(self.admin_token, "Username", "Pass", "false") - self.assertIn("true", create_new_user.text) + create_new_user = self.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "Pass") + + # try to login with new user + login = self.login(NewUser.name, NewUser.password) len_of_new_user_token = len(login.json()['content']) + self.assertEqual(200, create_new_user.status_code) self.assertEqual(32, len_of_new_user_token) def test_create_new_with_exist_name(self): - """create new user with already exist name""" - create_new_user = self.create_new_user(self.admin_token, "admin", "Pass", "false") - self.assertIn("true", create_new_user.text) + create_new_user = self.create_new_user(self.admin_token, DefaultUser.user, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("admin", "Pass") + + # try to login with new user + login = self.login(DefaultUser.user, NewUser.password) len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with a name what already exist") + self.assertNotEqual(32, len_of_new_user_token, "User was created with a name what already exist") def test_with_non_admin_token(self): - """create new user with usage of non admin token""" - login = self.login("slototc", "qwerty") - token = login.json()['content'] - create_new_user = self.create_new_user(token, "Username", "Pass", "false") - self.assertIn("false", create_new_user.text, "ERROR, user was created with user token") + # login with existed user + login = self.login(UserToTest.login, UserToTest.password) + user_token = login.json()['content'] + + # create new user with user token + create_new_user = self.create_new_user(user_token, NewUser.name, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "Pass") - text_of_login_message = str(login.content) - self.assertIn("ERROR", text_of_login_message, "ERROR, user was created with user token") - def test_give_invalid_admin_rights(self): + # try to login with new user + login_new_user = self.login(NewUser.name, NewUser.password) + self.assertEqual(200, login_new_user.status_code) + self.assertIn("ERROR", login_new_user.text, "User was created with user token") + def test_give_invalid_admin_rights(self): """create new user with invalid admin rights""" - create_new_user = self.create_new_user(self.admin_token, "Username", "Pass", "admin") - self.assertIn("Bad Request", create_new_user.text, "ERROR, user was created with invalid admin rights") + create_new_user = self.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.wrong_rights) + self.assertIn("Bad Request", create_new_user.text) self.assertEquals(400, create_new_user.status_code) self.assertNotEqual(200, create_new_user.status_code) - login = self.login("Username", "Pass") + + # try to login with new user + login = self.login(NewUser.name, NewUser.password) text_of_login_message = str(login.content) - self.assertIn("ERROR", text_of_login_message, "ERROR, user was created with invalid admin rights") + self.assertIn("ERROR", text_of_login_message, "User was created with invalid admin rights") def test_add_spaces_to_login(self): - """create new user with spaces on login""" - create_new_user = self.create_new_user(self.admin_token, "Username ", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_with_space = InvalidValues.values[0] + create_new_user = self.create_new_user(self.admin_token, login_with_space, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username ", "Pass") + + # try to login with new user + login = self.login(login_with_space, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR, user was created with spaces in login!") + self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces in login!") def test_login_contain_only_spaces(self): - """create new user with only spaces on login""" - create_new_user = self.create_new_user(self.admin_token, " ", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_spaces_only = InvalidValues.values[1] + create_new_user = self.create_new_user(self.admin_token, login_spaces_only, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login(" ", "Pass") + + # try to login with new user + login = self.login(login_spaces_only, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR, user was created with spaces only in login!") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces only in login!") def test_login_is_empty(self): - """create new user with empty login """ - create_new_user = self.create_new_user(self.admin_token, "", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_empty = InvalidValues.values[2] + create_new_user = self.create_new_user(self.admin_token, login_empty, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("", "Pass") + + # try to login with new user + login = self.login("", NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with empty login!") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with empty login!") def test_login_contain_symbols(self): - """Login contain !@#$%^&*()<> """ - create_new_user = self.create_new_user(self.admin_token, "!@#$%^&*()<>", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_symbols = InvalidValues.values[3] + create_new_user = self.create_new_user(self.admin_token, login_symbols, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("!@#$%^&*()<>", "Pass") + + # try to login with new user + login = self.login(login_symbols, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with !@#$%^&*()<> in login!") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with !@#$%^&*()<> in login!") def test_login_contain_cyrillic_letters(self): - """Login contain cyrillic letters""" - create_new_user = self.create_new_user(self.admin_token, "ыва", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_cyrillic = InvalidValues.values[4] + create_new_user = self.create_new_user(self.admin_token, login_cyrillic, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("ыва", "Pass") - len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with cyrillic letters in login") - def test_login_contain_ASCII_symbols(self): + # try to login with new user + login = self.login(login_cyrillic, NewUser.password) + len_of_new_user_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with cyrillic letters in login") + def test_login_contain_ascii_symbols(self): """Login contain ASCII symbols""" - create_new_user = self.create_new_user(self.admin_token, "ø¶", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_ascii = InvalidValues.values[5] + create_new_user = self.create_new_user(self.admin_token, login_ascii, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("ø¶", "Pass") + + # try to login with new user + login = self.login(login_ascii, NewUser.password) len_of_new_user_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) self.assertNotEqual(32, len_of_new_user_token, "ERROR. New user was created with ASCII symbols in login") - def test_login_contain_Japan_symbols(self): + def test_login_contain_japan_symbols(self): """Login contain Japan symbols""" - create_new_user = self.create_new_user(self.admin_token, "本本本本本", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_japan = InvalidValues.values[6] + create_new_user = self.create_new_user(self.admin_token, login_japan, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("本本本本本", "Pass") + + # try to login with new user + login = self.login(login_japan, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with Japan symbols in login") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with Japan symbols in login") def test_login_is_too_long(self): """Login is too long""" - create_new_user = self.create_new_user(self.admin_token, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" - "aaaaaaaaaaaaaaaaaaaaaaa", "Pass", "false") - self.assertIn("true", create_new_user.text) + login_too_long = InvalidValues.values[7] + create_new_user = self.create_new_user(self.admin_token, login_too_long, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") + + # try to login with new user + login = self.login(login_too_long, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long login") + self.assertNotEqual(32, len_of_new_user_token, " User was created with too long login") - def test_pass_contain_spaces(self): + def test_login_is_too_short(self): + """Login is too short""" + + login_too_short = InvalidValues.values[8] + create_new_user = self.create_new_user(self.admin_token, login_too_short, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + # try to login with new user + login = self.login(login_too_short, NewUser.password) + len_of_new_user_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, " User was created with too short login") + + def test_pass_contain_spaces(self): """Pass contain spaces""" - create_new_user = self.create_new_user(self.admin_token, "Username", "Pass ", "false") - self.assertIn("true", create_new_user.text) + pass_with_spaces = InvalidValues.values[0] + create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_with_spaces, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "Pass ") + + # try to login with new user + login = self.login(NewUser.name, pass_with_spaces) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with spaces in password") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces in password") def test_pass_contain_only_spaces(self): - """Pass contain spaces only""" - create_new_user = self.create_new_user(self.admin_token, "Username", " ", "false") - self.assertIn("true", create_new_user.text) + pass_spaces_only = InvalidValues.values[1] + create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_spaces_only, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", " ") + + # try to login with new user + login = self.login(NewUser.name, pass_spaces_only) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with spaces only in password!") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces only in password!") def test_pass_is_empty(self): - """create new user with empty pass""" - create_new_user = self.create_new_user(self.admin_token, "Username", "", "false") - self.assertIn("true", create_new_user.text) + pass_empty = InvalidValues.values[2] + create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_empty, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "") + + # try to login with new user + login = self.login(NewUser.name, pass_empty) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with empty pass!") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with empty pass!") def test_pass_contain_symbols(self): - """Pass contain !@#$%^&*()<> """ - create_new_user = self.create_new_user(self.admin_token, "Username", "!@#$%^&*()<>", "false") - self.assertIn("true", create_new_user.text) + pass_symbols = InvalidValues.values[3] + create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_symbols, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "!@#$%^&*()<>") + + # try to login with new user + login = self.login(NewUser.name, pass_symbols) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with !@#$%^&*()<> in password") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with !@#$%^&*()<> in password") def test_pass_contain_cyrillic_letters(self): - """Pass contain cyrillic letters""" - create_new_user = self.create_new_user(self.admin_token, "Username", "ыва", "false") - self.assertIn("true", create_new_user.text) + pass_cyrillic = InvalidValues.values[4] + create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_cyrillic, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "ыва") - len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with cyrillic letters in password") - def test_pass_contain_ASCII_symbols(self): + # try to login with new user + login = self.login(NewUser.name, pass_cyrillic) + len_of_new_user_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with cyrillic letters in password") + def test_pass_contain_ascii_symbols(self): """Login contain ASCII symbols""" - create_new_user = self.create_new_user(self.admin_token, "Username", "ø¶", "false") - self.assertIn("true", create_new_user.text) + pass_ascii = InvalidValues.values[5] + create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_ascii, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "ø¶") + + # try to login with new user + login = self.login(NewUser.name, pass_ascii) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. New user was created with ASCII symbols in password") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with ASCII symbols in password") def test_pass_contain_Japan_symbols(self): - """pass contain Japan symbols""" - create_new_user = self.create_new_user(self.admin_token, "Username", "本本本本本", "false") - self.assertIn("true", create_new_user.text) + pass_japan = InvalidValues.values[6] + create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_japan, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Username", "本本本本本") + + # try to login with new user + login = self.login(NewUser.name, pass_japan) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with Japan symbols in pass") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with Japan symbols in pass") def test_pass_is_too_long(self): - """Password is too long""" - create_new_user = self.create_new_user(self.admin_token, "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" - "aaaaaaaaaaaaaaaaaaaaaa", "Pass", "false") - self.assertIn("true", create_new_user.text) + pass_too_long = InvalidValues.values[7] + create_new_user = self.create_new_user(self.admin_token, pass_too_long, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) - login = self.login("Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "Pass") + + # try to login with new user + login = self.login(pass_too_long, NewUser.password) + len_of_new_user_token = len(login.json()['content']) + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with too long password") + + def test_pass_is_too_short(self): + """Password is too short""" + + pass_too_short = InvalidValues.values[8] + create_new_user = self.create_new_user(self.admin_token, pass_too_short, NewUser.password, NewUser.isUser) + self.assertTrue(create_new_user.text) + self.assertEqual(200, create_new_user.status_code) + + # try to login with new user + login = self.login(pass_too_short, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. User was created with too long password") + self.assertEqual(200, login.status_code) + self.assertNotEqual(32, len_of_new_user_token, "User was created with too long password") diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py index 88793ef..2507ec1 100644 --- a/tests/functional/tests_user_remove.py +++ b/tests/functional/tests_user_remove.py @@ -2,7 +2,7 @@ For getting valid response we need admin token and user name""" from tests.functional import ApiTestBase -from tests.constants.constants import DefaultUser +from tests.constants.constants import DefaultUser, UserToTest, InvalidValues, DefaultToken class TestRemoveUser(ApiTestBase): @@ -10,7 +10,6 @@ class TestRemoveUser(ApiTestBase): """Remove user with valid and not valid data""" def setUp(self): - """Get admin token""" super().setUp() @@ -18,39 +17,34 @@ def setUp(self): self.admin_token = response.json()['content'] def test_remove_user(self): - """delete user with valid data""" - removed_user = self.delete_user(self.admin_token, "akimatc") - get_answer = str(removed_user.json()['content']) - self.assertIn('True', get_answer) + removed_user = self.delete_user(self.admin_token, UserToTest.login) + self.assertTrue(removed_user.text) self.assertEqual(200, removed_user.status_code) # search user in user list get_user_list = self.get_all_users(self.admin_token) - self.assertNotIn("akimatc", get_user_list.text) + self.assertEqual(200, get_user_list.status_code) + self.assertNotIn(UserToTest.login, get_user_list.text, "User was not deleted") def test_delete_without_name(self): - """Try to delete user without name, only with token""" - removed_user = self.delete_user(self.admin_token, "") - get_answer = str(removed_user.json()['content']) + name_empty = InvalidValues.values[2] + removed_user = self.delete_user(self.admin_token, name_empty) self.assertEqual(200, removed_user.status_code) - self.assertNotIn('True', get_answer, "Error, we got deletion = True, without name") + self.assertIn("false", removed_user.text, "Error. User was deleted without name") def test_delete_without_token(self): - """Try to delete user without token, only with name""" - removed_user = self.delete_user("", "akimatc") - get_answer = str(removed_user.json()['content']) + token_empty = InvalidValues.values[2] + removed_user = self.delete_user(token_empty, UserToTest.login) self.assertEqual(200, removed_user.status_code) - self.assertNotIn('True', get_answer, "Error, we got deletion without token") - + self.assertIn("false", removed_user.text, "Error, we got deletion without token") def test_admin_delete_himself(self): - """Delete admin""" removed_user = self.delete_user(self.admin_token, DefaultUser.user) @@ -60,51 +54,40 @@ def test_admin_delete_himself(self): # search user in user list get_user_list = self.get_all_users(self.admin_token) - self.assertIn("admin", get_user_list.text, "Error, admin has deleted himself") - - # Try to login with deleted admin - login = self.login(DefaultUser.user, DefaultUser.password) - response = login.json()['content'] - let_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotIn('True', login.content.text) - self.assertNotEqual(32, let_token) - self.assertNotEqual('ERROR, user not found', response, "Error, admin has deleted himself") + self.assertIn(DefaultUser.user, get_user_list.text, "Error, admin has deleted himself") def test_user_delete_himself(self): - """User delete himself with user token""" - login = self.login("akimatc", "qwerty") + login = self.login(UserToTest.login, UserToTest.password) token = login.json()['content'] let_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertEqual(32, let_token) # Use User token to delete himself - removed_user = self.delete_user(token, "akimatc") + removed_user = self.delete_user(token, UserToTest.login) get_answer = str(removed_user.json()['content']) self.assertEqual(200, removed_user.status_code) self.assertIn('False', get_answer, 'ERROR. User was deleted with user token!') self.assertNotEqual(32, len(get_answer)) - # search user in user list + # search deleted user in user list get_user_list = self.get_all_users(self.admin_token) - self.assertIn("akimatc", get_user_list.text, "Error, user delete himself with user token") + self.assertIn(UserToTest.login, get_user_list.text, "Error, user delete himself with user token") def test_user_token_delete_admin(self): - """Login with user and use user token to delete admin""" # login with user and get user token - login = self.login("akimatc", "qwerty") + login = self.login(UserToTest.login, UserToTest.password) token = login.json()['content'] let_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertEqual(32, let_token) # del admin with user token - removed_user = self.delete_user(token, "admin") + removed_user = self.delete_user(token, DefaultUser.user) get_answer = str(removed_user.json()['content']) self.assertEqual(200, removed_user.status_code) self.assertIn('False', get_answer, 'ERROR. Admin was deleted with user token!') @@ -112,42 +95,29 @@ def test_user_token_delete_admin(self): # search admin in user list get_user_list = self.get_all_users(self.admin_token) - self.assertIn("admin", get_user_list.text, "Error, user delete admin with user token") + self.assertIn(DefaultUser.user, get_user_list.text, "Error, user delete admin with user token") def test_admin_token_not_right(self): - """Use wrong token""" - invalid_token = "0123456789ABCDEF0123456789ABCDEF" - removed_user = self.delete_user(invalid_token, "akimatc") + invalid_token = DefaultToken.token + removed_user = self.delete_user(invalid_token, UserToTest.login) get_answer = str(removed_user.json()['content']) len_token = len(get_answer) self.assertEqual(200, removed_user.status_code) self.assertNotIn('True', get_answer) self.assertNotEqual(32, len_token) - # search admin in user list + # search deleted user in user list get_user_list = self.get_all_users(self.admin_token) - self.assertIn("akimatc", get_user_list.text, "Error, user was deleted with wrong token") + self.assertIn(UserToTest.login, get_user_list.text, "Error, user was deleted with wrong token") def test_user_not_exist_deletion(self): - - """Detele not exist user""" + """Delete not exist user""" removed_user = self.delete_user(self.admin_token, "testuser") self.assertEqual(200, removed_user.status_code) - # search testuser in user list + # search test user in user list get_user_list = self.get_all_users(self.admin_token) self.assertNotIn("testuser", get_user_list.text, "Error, not exist user was deleted") - - def test_user_not_valid(self): - - """Delete user with not valid name""" - - removed_user = self.delete_user(self.admin_token, "akimatg") - self.assertEqual(200, removed_user.status_code) - - # search akimatg in user list - get_user_list = self.get_all_users(self.admin_token) - self.assertNotIn("akimatg", get_user_list.text, "Error, not exist user was deleted") From 43b5180f59c84ce5f5fcf6cc3edd2c50577e5c92 Mon Sep 17 00:00:00 2001 From: shtepsel Date: Wed, 31 Oct 2018 14:42:18 -0700 Subject: [PATCH 53/74] half of tests reworked --- tests/constants/constants.py | 4 +- tests/functional/__init__.py | 17 +++++++ tests/functional/tests_locked.py | 85 +++++++++++++++----------------- 3 files changed, 61 insertions(+), 45 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index e4e3b80..b05b4f9 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -40,7 +40,7 @@ class InitUsers: "vvasylystc": "qwerty"} -class InitFakeUsers: +class InitFake: """The dictionary with fake users""" fake_users = {"administrator": "QWERTY", @@ -49,6 +49,8 @@ class InitFakeUsers: "vokodumer": "qwerty", "vasya": "OKonokhtc"} + wrong_password = 'yaroslav' + class BaseUrl: diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index f15703b..cb13664 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -13,18 +13,35 @@ def setUp(self): self.request_session = requests.session() def login(self, name:str, password:str) -> object: + """Login user""" return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) def get_locked_users(self, kwargs): + """Get locked users""" return self.request_session.get(generate_full_url(Endpoints.locked_users), params = kwargs) def get_locked_admins(self, kwargs): + """Get locked admins""" return self.request_session.get(generate_full_url(Endpoints.locked_admins), params = kwargs) def get_logined_admins(self, kwargs): + """Get logined admins""" return self.request_session.get(generate_full_url(Endpoints.login_admins), params = kwargs) + def lock_user(self,user_to_lock, kwargs): + """Lock user by manual command""" + return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) + + def unlock_all_users(self, kwargs): + """Unlock all users""" + return self.request_session.put(generate_full_url(Endpoints.locked_reset), params=kwargs) + + def unlock_user(self, user_to_lock, kwargs): + """Unlock user by manual command""" + return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) + def get_logined_users(self, kwargs): + """Get logined users""" return self.request_session.get(generate_full_url(Endpoints.login_users), params = kwargs) def logout(self, name: str, token: str): diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 07bf7f0..6cdc5aa 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -3,8 +3,9 @@ import requests from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser, InitUsers, InitFakeUsers +from tests.constants.constants import Endpoints, DefaultUser, InitUsers, InitFake from tests.utils.helper import generate_full_url +from random import choice class TestLocked(ApiTestBase): @@ -15,6 +16,7 @@ def setUp(self): super().setUp() response = self.login(DefaultUser.user, DefaultUser.password) self.admin_token = response.json()['content'] + self.kwargs = {'token': self.admin_token} def tearDown(self): """Reset api after each test""" @@ -22,67 +24,62 @@ def tearDown(self): def test_locked(self): """Test functionality of locking users""" - passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps - users = list(InitUsers.users) - users.remove('admin') - for user in users: - for password in passwords: - self.login(user, password) - kwargs = {'token': self.admin_token} - locked_users_request = self.get_locked_users(kwargs) + users = InitUsers.users.copy() + users.pop('admin', None) + user = choice(list(users.keys())) # returning random user + wrong_password = InitFake.wrong_password + for _ in range(3): + self.login(user, wrong_password) + locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] - self.assertEqual(locked_users, - ('0 \totlumtc\n1 \tvbudktc\n2 \tvvasylystc\n3 \tkhalaktc\n4' - ' \tslototc\n5 \tOKonokhtc\n6 \takimatc\n7 \tkilinatc\n')) + self.assertIn(user, locked_users) def test_not_locked(self): """User should not be locked""" - passwords = ['', 'password', 'qwerty'] users = InitUsers.users.copy() users.pop('admin', None) - for user in users: - for password in passwords: - self.login(user, password) - kwargs = {'token': self.admin_token} - locked_users_request = self.get_locked_users(kwargs) + user = choice(list(users.keys())) # returning random user + wrong_passwords = ['', 'password'] + for wrong_password in wrong_passwords: + self.login(user, wrong_password) + locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] - self.assertEqual(locked_users, '') + self.assertNotIn(user, locked_users) def test_manual_lock(self): """Test functionality of locking users by manual command""" - users = list(InitUsers.users) - users.remove('admin') - user_to_lock = users[1] - kwargs = {'token': self.admin_token, 'name': user_to_lock} - requests.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) - locked_users_request1 = self.get_locked_users(kwargs) + users = InitUsers.users.copy() + users.pop('admin', None) + user_to_lock = choice(list(users.keys())) # returning random user + self.kwargs['name'] = user_to_lock + self.lock_user(user_to_lock, self.kwargs) + locked_users_request1 = self.get_locked_users(self.kwargs) self.assertIn(user_to_lock, locked_users_request1.text) def test_manual_unlock(self): """Test functionality of unlocking users by manual command""" - users = list(InitUsers.users) - users.remove('admin') - passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps - user_to_lock = users[3] - for password in passwords: - self.login(user_to_lock, password) - kwargs = {'token': self.admin_token, 'name': user_to_lock} - requests.put((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) - locked_users_request = self.get_locked_users(kwargs) + users = InitUsers.users.copy() + users.pop('admin', None) + user_to_lock = choice(list(users.keys())) # returning random user + wrong_password = InitFake.wrong_password + for _ in range(3): + self.login(user_to_lock, wrong_password) + self.kwargs['name'] = user_to_lock + self.unlock_user(user_to_lock, self.kwargs) + locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.text self.assertNotIn(user_to_lock, locked_users) def test_reset_locked_admin_token(self): """Test functionality of unlocking all users with admin token""" - passwords = ['', 'password', 'birthday', 'petname'] # number of passwords determines login attemps - users = list(InitUsers.users) - users.remove('admin') - for user in users: - for password in passwords: - self.login(user, password) - kwargs = {'token': self.admin_token} - requests.put(generate_full_url(Endpoints.locked_reset), params=kwargs) - locked_users_request = self.get_locked_users(kwargs) + # passwords = ['', 'password', 'birthday'] # number of passwords determines login attemps + users = InitUsers.users.copy() + users.pop('admin', None) + wrong_password = InitFake.wrong_password + for user in users.keys(): + self.login(user, wrong_password) + self.unlock_all_users(self.kwargs) + locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') @@ -137,7 +134,7 @@ def test_manual_lock_user_token(self): def test_locking_unexisting_user(self): """Test functionality of locking unexisting users""" - fake_users = InitFakeUsers.fake_users.copy() + fake_users = InitFake.fake_users.copy() passwords = ['', 'password', 'birthday', 'petname'] for user in fake_users.keys(): for password in passwords: From b292975e754ae997075835d17f29f188955c9319 Mon Sep 17 00:00:00 2001 From: abertash Date: Thu, 1 Nov 2018 00:40:34 +0200 Subject: [PATCH 54/74] refactoring. --- tests/constants/constants.py | 7 +++---- tests/functional/__init__.py | 14 +++++++++++--- tests/functional/tests_tokenlifetime.py | 21 --------------------- 3 files changed, 14 insertions(+), 28 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index b40062b..9038873 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -60,15 +60,14 @@ class Endpoints: tokenlifetime = "/tokenlifetime" admins = "/admins" login_admins = "/login/admins" - locked_admins ="/locked/admins" + locked_admins = "/locked/admins" users = "/users" login_users = "/login/users" login_tockens = "/login/tockens" locked_users = "/locked/users" - locked_user= "/locked/user" + locked_user = "/locked/user" locked_reset = "/locked/reset" item_user = "/item/user" item = "/item" items = "/items" - itemindexes ="/itemindexes" - + itemindexes = "/itemindexes" diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index f0de437..0fa2463 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -7,9 +7,6 @@ class ApiTestBase(unittest.TestCase): - def get_reset(self): - return self.request_session.get(generate_full_url(Endpoints.reset)) - def setUp(self): self.request_session = requests.session() @@ -17,18 +14,29 @@ def login(self, name, password): return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) def change_cool_down_time(self, admin_token, new_value): + """Change cool down time""" return self.request_session.put(generate_full_url(Endpoints.cooldowntime), params={"token": admin_token, "time": new_value}) def get_cool_down_time(self): + """Get cool down time""" return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) def change_token_life_time(self, admin_token, new_value): + """Change token life time""" return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), params={"token": admin_token, "time": new_value}) def get_token_life_time(self): + """Get token life time""" return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) def get_all_users(self, admin_token): + """Get all users""" return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) + + def tearDown(self): + """Define close request session and reset API data + that will be executed after each test method.""" + self.request_session.get(generate_full_url(Endpoints.reset)) + self.request_session.close() diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py index bef80b3..3ff9783 100644 --- a/tests/functional/tests_tokenlifetime.py +++ b/tests/functional/tests_tokenlifetime.py @@ -27,9 +27,6 @@ def test_set_token_life_time_admin_positive(self): Change the token life time value by admin (positive) """ - # must use, because after get_token_life_time = 0, admin logout - self.get_reset() - new_tlt = get_new_value_different_func(self.get_token_life_time, 200000, 100000) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) @@ -49,9 +46,6 @@ def test_set_token_life_time_admin_negative(self): Change the token life time value by admin (negative) """ - # must use, because after et_token_life_time = 0, admin logout - self.get_reset() - new_tlt = get_new_value_different_func(self.get_token_life_time, -200000, -100000) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) @@ -71,9 +65,6 @@ def test_set_token_life_time_admin_zero(self): Change the token life time value by admin (zero) """ - # must use, because after et_token_life_time = 0, admin logout - self.get_reset() - new_tlt = get_new_value_different_func(self.get_token_life_time, 0, 0) login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) @@ -93,9 +84,6 @@ def test_set_token_life_time_admin_none(self): Change the token life time value by admin (None) """ - # must use, because after et_token_life_time = 0, admin logout - self.get_reset() - new_tlt = None def_tlt = 1000 @@ -116,9 +104,6 @@ def test_set_token_life_time_admin_float(self): Change the token life time value by admin (float) """ - # must use, because after et_token_life_time = 0, admin logout - self.get_reset() - new_tlt = get_new_value_different_func(self.get_token_life_time, 200000.555, 100000) resp = self.get_token_life_time() @@ -140,9 +125,6 @@ def test_set_token_life_time_admin_text(self): Change the token life time value by admin (text) """ - # must use, because after et_token_life_time = 0, admin logout - self.get_reset() - new_tlt = "f%kdm525!(" resp = self.get_token_life_time() @@ -164,9 +146,6 @@ def test_set_token_life_time_user(self): Change the token life time value by user (without admin rights) """ - # must use, because after et_token_life_time = 0, admin logout - self.get_reset() - new_tlt = get_new_value_different_func(self.get_token_life_time, 500000, 100000) resp = self.get_token_life_time() From 02d1091860f2e80a29e9aff8943e7dbc538cc274 Mon Sep 17 00:00:00 2001 From: shtepsel Date: Thu, 1 Nov 2018 01:20:10 -0700 Subject: [PATCH 55/74] second half of tests reworked --- tests/constants/constants.py | 13 ++++ tests/functional/tests_locked.py | 123 ++++++++++++++----------------- 2 files changed, 67 insertions(+), 69 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index b05b4f9..3d4bf43 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -6,6 +6,11 @@ class DefaultUser: user = "admin" password = "qwerty" + user_akimatc = "akimatc" + user_admin = "admin" + password_akimatc = "qwerty" + password_admin = "qwerty" + class DefaultToken: @@ -56,6 +61,14 @@ class BaseUrl: base_url = "http://localhost:8080" +class NewUser: + """Constants to create new user""" + + name = "Username" + password = "newtestpass" + isAdmin = "true" + isUser = "false" + wrong_rights = "admen" class Endpoints: diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 6cdc5aa..f303709 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -3,7 +3,7 @@ import requests from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser, InitUsers, InitFake +from tests.constants.constants import Endpoints, DefaultUser, InitUsers, InitFake, NewUser from tests.utils.helper import generate_full_url from random import choice @@ -14,7 +14,7 @@ class TestLocked(ApiTestBase): def setUp(self): """Return admin token""" super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) + response = self.login(DefaultUser.user_admin, DefaultUser.password_admin) self.admin_token = response.json()['content'] self.kwargs = {'token': self.admin_token} @@ -26,7 +26,7 @@ def test_locked(self): """Test functionality of locking users""" users = InitUsers.users.copy() users.pop('admin', None) - user = choice(list(users.keys())) # returning random user + user = choice(list(users.keys())) # returning random user wrong_password = InitFake.wrong_password for _ in range(3): self.login(user, wrong_password) @@ -93,27 +93,25 @@ def test_reset_locked_empty_token(self): def test_locked_admins(self): """Test functionality of locking admins""" - new_user_name = 'Shtepsel' - new_user_pass = 'qwerty' + new_user_name = NewUser.name + new_user_pass = NewUser.password self.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') - passwords = ['', 'password', 'birthday', 'petname'] - for password in passwords: - self.login(new_user_name, password) - kwargs = {'token': self.admin_token} - locked_admins = self.get_locked_admins(kwargs) + wrong_password = InitFake.wrong_password + for _ in range(3): + self.login(new_user_name, wrong_password) + locked_admins = self.get_locked_admins(self.kwargs) self.assertIn(new_user_name, locked_admins.text) def test_not_locked_admin(self): """Admin should not be locked""" - new_user_name = 'Shtepsel' - new_user_pass = 'qwerty' + new_user_name = NewUser.name + new_user_pass = NewUser.password self.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') - passwords = ['', 'password', 'qwerty'] + passwords = ['', 'password', new_user_pass] for password in passwords: self.login(new_user_name, password) - kwargs = {'token': self.admin_token} - locked_admins = self.get_locked_admins(kwargs) - logined_admins = self.get_logined_admins(kwargs) + locked_admins = self.get_locked_admins(self.kwargs) + logined_admins = self.get_logined_admins(self.kwargs) self.assertNotIn(new_user_name, locked_admins.text) self.assertIn(new_user_name, logined_admins.text) @@ -121,53 +119,45 @@ def test_manual_lock_user_token(self): """Test functionality of locking users by manual command with user token""" users = InitUsers.users.copy() users.pop('admin', None) - user_to_lock = list(users.keys())[1] - tokens = [] - for user, password in users.items(): - login_for_token = self.login(user, password) - tokens.append(login_for_token.json()['content']) - for token in tokens: - kwargs = {'token': token, 'name': user_to_lock} - requests.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) - locked_users_request1 = self.get_locked_users(kwargs) - self.assertNotIn(user_to_lock, locked_users_request1.text) + user, password = users.popitem() # user for login + user_to_lock = choice(list(users.keys())) # returning random user for lock + login_for_token = self.login(user, password) + token = login_for_token.json()['content'] + fake_kwargs = {'token': token, 'name': user_to_lock} + self.lock_user(user_to_lock, fake_kwargs) + locked_users_request1 = self.get_locked_users(self.kwargs) + self.assertNotIn(user_to_lock, locked_users_request1.text) def test_locking_unexisting_user(self): """Test functionality of locking unexisting users""" - fake_users = InitFake.fake_users.copy() - passwords = ['', 'password', 'birthday', 'petname'] - for user in fake_users.keys(): - for password in passwords: - self.login(user, password) - kwargs = {'token': self.admin_token} - locked_users_request = self.get_locked_users(kwargs) + fake_user, fake_password = choice(list(InitFake.fake_users.items())) + for _ in range(3): + self.login(fake_user, fake_password) + locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] - self.assertAlmostEqual(locked_users, '') + print(repr(locked_users)) + self.assertEqual(locked_users, '') - def test_get_locked_amins_user_token(self): + def test_get_locked_admins_user_token(self): """Discovering locked admins with user token""" users = InitUsers.users.copy() users.pop('admin', None) - tokens = [] - passwords = ['', 'password', 'birthday', 'petname'] - for password in passwords: - self.login('admin', password) - for user, password in users.items(): - login_for_token = self.login(user, password) - tokens.append(login_for_token.json()['content']) - for token in tokens: - kwargs = {'token': token} - locked_admins_request = self.get_locked_admins(kwargs) - locked_admin = locked_admins_request.json()['content'] - self.assertEqual(locked_admin, '') + user, password = choice(list(users.items())) + for _ in range(3): + self.login(DefaultUser.user_admin, InitFake.wrong_password) # locking admin + login_for_token = self.login(user, password) + token = login_for_token.json()['content'] + self.kwargs['token'] = token + locked_admins_request = self.get_locked_admins(self.kwargs) + locked_admin = locked_admins_request.json()['content'] + self.assertEqual(locked_admin, '') def test_get_locked_admins_empty_token(self): """Discovering locked admins with empty token""" - passwords = ['', 'password', 'birthday', 'petname'] - for password in passwords: - self.login('admin', password) - kwargs = {'token': ''} - locked_admins_request = self.get_locked_admins(kwargs) + for _ in range(3): + self.login(DefaultUser.user_admin, InitFake.wrong_password) + self.kwargs['token'] = '' + locked_admins_request = self.get_locked_admins(self.kwargs) locked_admin = locked_admins_request.json()['content'] self.assertEqual(locked_admin, '') @@ -175,15 +165,13 @@ def test_get_locked_users_user_token(self): """Discovering locked users with user token""" users = InitUsers.users.copy() users.pop('admin', None) - us, pas = users.popitem() - login_for_user_token = self.login(us, pas) + user, pasword = users.popitem() + login_for_user_token = self.login(user, pasword) user_token = login_for_user_token.json()['content'] - passwords = ['', 'password', 'birthday', 'petname'] - for user in users.keys(): - for password in passwords: - self.login(user, password) - kwargs = {'token': user_token} - locked_users_request = self.get_locked_users(kwargs) + user_to_lock = list(users.keys())[0] + self.login(user_to_lock, InitFake.wrong_password) + self.kwargs['token'] = user_token + locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') @@ -191,13 +179,10 @@ def test_get_locked_users_empty_token(self): """Discovering locked users with empty token""" users = InitUsers.users.copy() users.pop('admin', None) - passwords = ['', 'password', 'birthday', 'petname'] - for user in users.keys(): - for password in passwords: - self.login(user, password) - kwargs = {'token': ''} - locked_users_request = self.get_locked_users(kwargs) + user_to_lock = list(users.keys())[0] + for _ in range(3): + self.login(user_to_lock, InitFake.wrong_password) + self.kwargs['token'] = '' + locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] - self.assertEqual(locked_users, '') - - + self.assertEqual(locked_users, '') \ No newline at end of file From 8f29869835b3f6079443ddd88aabfcefab666d45 Mon Sep 17 00:00:00 2001 From: shtepsel Date: Thu, 1 Nov 2018 02:09:51 -0700 Subject: [PATCH 56/74] saving regress --- tests/constants/constants.py | 59 +++++---- tests/functional/__init__.py | 204 ++++++++++++++++++++++++++----- tests/functional/tests_locked.py | 30 ++--- 3 files changed, 224 insertions(+), 69 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index 3d4bf43..a314116 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -2,7 +2,7 @@ class DefaultUser: - + """Default user with admin rights. Has admin token""" user = "admin" password = "qwerty" @@ -12,30 +12,44 @@ class DefaultUser: password_admin = "qwerty" -class DefaultToken: +class Users: + """Default valid user, password and fake user, password""" + valid_user = "vvasylystc" + valid_password = "qwerty" + fake_user = "vVASYLystc333" + fake_password = "Qwerty123" + +class DefaultToken: + """Default token""" token = "0123456789ABCDEF0123456789ABCDEF" -class DefaultItem: +INVALID_TOKEN = "2134rfvsd231g45" + +class DefaultItem: + """Default item for items""" item = "empty" class DefaultNum: - + """Default number for items""" num = 1000 -class DefaultBool: +VALID_STATUS_CODE = 200 + +class DefaultBool: + """Default bool for items""" bool = False class InitUsers: + """The dictionary of all valid users""" - users = {"admin": "qwerty", - "akimatc": "qwerty", + users = {"akimatc": "qwerty", "khalaktc": "qwerty", "kilinatc": "qwerty", "OKonokhtc": "qwerty", @@ -45,20 +59,8 @@ class InitUsers: "vvasylystc": "qwerty"} -class InitFake: - - """The dictionary with fake users""" - fake_users = {"administrator": "QWERTY", - "akimatc1": "qwerty", - "petro": "qwerty", - "vokodumer": "qwerty", - "vasya": "OKonokhtc"} - - wrong_password = 'yaroslav' - - class BaseUrl: - + """Url for connecting to API""" base_url = "http://localhost:8080" class NewUser: @@ -70,8 +72,14 @@ class NewUser: isUser = "false" wrong_rights = "admen" -class Endpoints: +class InvalidUrl: + """Invalid url for testing exceptions""" + invalid_url = "http://localhost:80801" + + +class Endpoints: + """All endpoints in API""" reset = "/reset" login = "/login" logout = "/logout" @@ -87,7 +95,12 @@ class Endpoints: locked_users = "/locked/users" locked_user = "/locked/user/" locked_reset = "/locked/reset" - item_user = "/item/user" - item = "/item/" + item_user = "/item/user/{name}" + item_user_by_index = "/item/{index}/user/{name}" + item = "/item/{index}" items = "/items" itemindexes = "/itemindexes" + + +ITEM_NAMES = ["Product", "Car", "Soap", "TV", "Wine", "Tea", "Coffee", "Bread", "apple", "laptop", +"fish", "cat", "dog", "pineapple", "phone", "number1", "number2"] \ No newline at end of file diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index cb13664..a1780f2 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -1,56 +1,204 @@ import unittest import requests -from urllib3 import response from tests.constants.constants import Endpoints from tests.utils.helper import generate_full_url +from requests import request class ApiTestBase(unittest.TestCase): - + """Main class for testing""" def setUp(self): + """Define open request session that will be executed before each test method.""" self.request_session = requests.session() - def login(self, name:str, password:str) -> object: - """Login user""" - return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) + def reset(self): + """Reset API""" + return self.request_session.get(generate_full_url(Endpoints.reset)) + + def login(self, name: str, password: str) -> request: + """Login user with name and password.""" + return self.request_session.post(generate_full_url(Endpoints.login), + params={"name": name, "password": password}) + + def logout(self, name: str, token: str) -> request: + """Logout user with name and user token.""" + return self.request_session.post(generate_full_url(Endpoints.logout), + params={"name": name, "token": token}) + + def login_admins(self, token: str) -> request: + """Logged admins""" + return self.request_session.get(generate_full_url(Endpoints.login_admins), + params={"token": token}) + + def login_users(self, token: str) -> request: + """Logged users""" + return self.request_session.get(generate_full_url(Endpoints.login_users), + params={"token": token}) + + def login_tockens(self, token: str) -> request: + """Alive tokens""" + return self.request_session.get(generate_full_url(Endpoints.login_tockens), + params={"token": token}) + + def admins(self, token: str) -> request: + """All admins""" + return self.request_session.get(generate_full_url(Endpoints.admins), + params={"token": token}) + + def get_user_all_items(self, user, admin_token): + """Get all user items""" + return self.request_session.get(generate_full_url(Endpoints.item_user).format(name=user), + params={"token": admin_token}) + + def get_user_item_by_index(self, index, user, admin_token): + """Get user item by index""" + return self.request_session.get(generate_full_url(Endpoints.item_user_by_index).format(index=index, name=user), + params={"token": admin_token}) + + def add_item(self, index, token, item): + """Add item""" + return self.request_session.post(generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def delete_item(self, index, token): + """Delete item""" + return self.request_session.delete(generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def update_item(self, index, token, item): + """Update item""" + return self.request_session.put(generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def get_item(self, index, token): + """Get item by index""" + return self.request_session.get(generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def get_item_indexes(self, token): + """Get all item indexes""" + return self.request_session.get(generate_full_url(Endpoints.itemindexes), params={"token": token}) + + def get_all_items(self, token): + """Get all items by user""" + return self.request_session.get(generate_full_url(Endpoints.items), params={"token": token}) + + def change_cool_down_time(self, admin_token, new_value): + """Change cool down time""" + return self.request_session.put(generate_full_url(Endpoints.cooldowntime), + params={"token": admin_token, "time": new_value}) + + def get_cool_down_time(self): + """Get cool down time""" + return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) + + def change_token_life_time(self, admin_token, new_value): + """Change token life time""" + return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), + params={"token": admin_token, "time": new_value}) + + def get_token_life_time(self): + """Get token life time""" + return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) + + def get_all_users(self, admin_token): + """Get all users""" + return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) def get_locked_users(self, kwargs): - """Get locked users""" - return self.request_session.get(generate_full_url(Endpoints.locked_users), params = kwargs) + """Get locked users""" + return self.request_session.get(generate_full_url(Endpoints.locked_users), params = kwargs) def get_locked_admins(self, kwargs): """Get locked admins""" return self.request_session.get(generate_full_url(Endpoints.locked_admins), params = kwargs) - def get_logined_admins(self, kwargs): - """Get logined admins""" - return self.request_session.get(generate_full_url(Endpoints.login_admins), params = kwargs) - - def lock_user(self,user_to_lock, kwargs): + def lock_user(self, user_to_lock, admin_token): """Lock user by manual command""" - return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) + return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), + params= {"token": admin_token}) def unlock_all_users(self, kwargs): """Unlock all users""" - return self.request_session.put(generate_full_url(Endpoints.locked_reset), params=kwargs) + return self.request_session.put(generate_full_url(Endpoints.locked_reset), + params= {"token": admin_token}) def unlock_user(self, user_to_lock, kwargs): """Unlock user by manual command""" - return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) - - def get_logined_users(self, kwargs): - """Get logined users""" - return self.request_session.get(generate_full_url(Endpoints.login_users), params = kwargs) - - def logout(self, name: str, token: str): - return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) - - def create_new_user(self, adminToken, newName, newPassword, adminRights): - return self.request_session.post(generate_full_url(Endpoints.user), - {"token": adminToken, "name": newName, "password": newPassword, - "rights": adminRights}) + return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_lock), + params=kwargs) def tearDown(self): - return self.request_session.get(generate_full_url(Endpoints.reset)) + """Define close request session and reset API data + that will be executed after each test method.""" + self.request_session.get(generate_full_url(Endpoints.reset)) + self.request_session.close() + + +class Ascertains(unittest.TestCase): + """Class for ascertains""" + + def check_status_code_200(self, status_code: int): + """Check if response status code is valid""" + self.assertEqual(status_code, 200, "Error response status code (expected 200)") + + + +# import unittest +# import requests +# +# from urllib3 import response +# from tests.constants.constants import Endpoints +# from tests.utils.helper import generate_full_url +# +# +# class ApiTestBase(unittest.TestCase): +# +# +# def setUp(self): +# self.request_session = requests.session() +# +# def login(self, name:str, password:str) -> object: +# """Login user""" +# return self.request_session.post(generate_full_url(Endpoints.login), {"name": name, "password": password}) +# +# def get_locked_users(self, kwargs): +# """Get locked users""" +# return self.request_session.get(generate_full_url(Endpoints.locked_users), params = kwargs) +# +# def get_locked_admins(self, kwargs): +# """Get locked admins""" +# return self.request_session.get(generate_full_url(Endpoints.locked_admins), params = kwargs) +# +# def get_logined_admins(self, kwargs): +# """Get logined admins""" +# return self.request_session.get(generate_full_url(Endpoints.login_admins), params = kwargs) +# +# def lock_user(self,user_to_lock, kwargs): +# """Lock user by manual command""" +# return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) +# +# def unlock_all_users(self, kwargs): +# """Unlock all users""" +# return self.request_session.put(generate_full_url(Endpoints.locked_reset), params=kwargs) +# +# def unlock_user(self, user_to_lock, kwargs): +# """Unlock user by manual command""" +# return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_lock), params=kwargs) +# +# def get_logined_users(self, kwargs): +# """Get logined users""" +# return self.request_session.get(generate_full_url(Endpoints.login_users), params = kwargs) +# +# def logout(self, name: str, token: str): +# return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) +# +# def create_new_user(self, adminToken, newName, newPassword, adminRights): +# return self.request_session.post(generate_full_url(Endpoints.user), +# {"token": adminToken, "name": newName, "password": newPassword, +# "rights": adminRights}) +# +# def tearDown(self): +# return self.request_session.get(generate_full_url(Endpoints.reset)) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index f303709..aae7388 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -3,7 +3,7 @@ import requests from tests.functional import ApiTestBase -from tests.constants.constants import Endpoints, DefaultUser, InitUsers, InitFake, NewUser +from tests.constants.constants import Endpoints, DefaultUser, InitUsers, NewUser, Users from tests.utils.helper import generate_full_url from random import choice @@ -25,9 +25,8 @@ def tearDown(self): def test_locked(self): """Test functionality of locking users""" users = InitUsers.users.copy() - users.pop('admin', None) user = choice(list(users.keys())) # returning random user - wrong_password = InitFake.wrong_password + wrong_password = Users.fake_password for _ in range(3): self.login(user, wrong_password) locked_users_request = self.get_locked_users(self.kwargs) @@ -37,7 +36,6 @@ def test_locked(self): def test_not_locked(self): """User should not be locked""" users = InitUsers.users.copy() - users.pop('admin', None) user = choice(list(users.keys())) # returning random user wrong_passwords = ['', 'password'] for wrong_password in wrong_passwords: @@ -49,7 +47,6 @@ def test_not_locked(self): def test_manual_lock(self): """Test functionality of locking users by manual command""" users = InitUsers.users.copy() - users.pop('admin', None) user_to_lock = choice(list(users.keys())) # returning random user self.kwargs['name'] = user_to_lock self.lock_user(user_to_lock, self.kwargs) @@ -59,9 +56,8 @@ def test_manual_lock(self): def test_manual_unlock(self): """Test functionality of unlocking users by manual command""" users = InitUsers.users.copy() - users.pop('admin', None) user_to_lock = choice(list(users.keys())) # returning random user - wrong_password = InitFake.wrong_password + wrong_password = Users.fake_password for _ in range(3): self.login(user_to_lock, wrong_password) self.kwargs['name'] = user_to_lock @@ -74,8 +70,7 @@ def test_reset_locked_admin_token(self): """Test functionality of unlocking all users with admin token""" # passwords = ['', 'password', 'birthday'] # number of passwords determines login attemps users = InitUsers.users.copy() - users.pop('admin', None) - wrong_password = InitFake.wrong_password + wrong_password = Users.fake_password for user in users.keys(): self.login(user, wrong_password) self.unlock_all_users(self.kwargs) @@ -96,7 +91,7 @@ def test_locked_admins(self): new_user_name = NewUser.name new_user_pass = NewUser.password self.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') - wrong_password = InitFake.wrong_password + wrong_password = Users.fake_password for _ in range(3): self.login(new_user_name, wrong_password) locked_admins = self.get_locked_admins(self.kwargs) @@ -118,7 +113,6 @@ def test_not_locked_admin(self): def test_manual_lock_user_token(self): """Test functionality of locking users by manual command with user token""" users = InitUsers.users.copy() - users.pop('admin', None) user, password = users.popitem() # user for login user_to_lock = choice(list(users.keys())) # returning random user for lock login_for_token = self.login(user, password) @@ -130,7 +124,8 @@ def test_manual_lock_user_token(self): def test_locking_unexisting_user(self): """Test functionality of locking unexisting users""" - fake_user, fake_password = choice(list(InitFake.fake_users.items())) + fake_user = Users.fake_user + fake_password = Users.fake_password for _ in range(3): self.login(fake_user, fake_password) locked_users_request = self.get_locked_users(self.kwargs) @@ -141,10 +136,9 @@ def test_locking_unexisting_user(self): def test_get_locked_admins_user_token(self): """Discovering locked admins with user token""" users = InitUsers.users.copy() - users.pop('admin', None) user, password = choice(list(users.items())) for _ in range(3): - self.login(DefaultUser.user_admin, InitFake.wrong_password) # locking admin + self.login(DefaultUser.user_admin, Users.fake_password) # locking admin login_for_token = self.login(user, password) token = login_for_token.json()['content'] self.kwargs['token'] = token @@ -155,7 +149,7 @@ def test_get_locked_admins_user_token(self): def test_get_locked_admins_empty_token(self): """Discovering locked admins with empty token""" for _ in range(3): - self.login(DefaultUser.user_admin, InitFake.wrong_password) + self.login(DefaultUser.user_admin, Users.fake_password) self.kwargs['token'] = '' locked_admins_request = self.get_locked_admins(self.kwargs) locked_admin = locked_admins_request.json()['content'] @@ -169,7 +163,7 @@ def test_get_locked_users_user_token(self): login_for_user_token = self.login(user, pasword) user_token = login_for_user_token.json()['content'] user_to_lock = list(users.keys())[0] - self.login(user_to_lock, InitFake.wrong_password) + self.login(user_to_lock, Users.fake_password) self.kwargs['token'] = user_token locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] @@ -181,8 +175,8 @@ def test_get_locked_users_empty_token(self): users.pop('admin', None) user_to_lock = list(users.keys())[0] for _ in range(3): - self.login(user_to_lock, InitFake.wrong_password) + self.login(user_to_lock, Users.fake_password) self.kwargs['token'] = '' locked_users_request = self.get_locked_users(self.kwargs) locked_users = locked_users_request.json()['content'] - self.assertEqual(locked_users, '') \ No newline at end of file + self.assertEqual(locked_users, '') From 3e8edfa5d32b78b4ef1b426204377543401e1398 Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Thu, 1 Nov 2018 12:31:13 +0200 Subject: [PATCH 57/74] test reworked with correspondance to dev/constants and dev/functional/init.py --- tests/functional/__init__.py | 34 ++++++++++++-------- tests/functional/tests_locked.py | 55 ++++++++++++++------------------ 2 files changed, 44 insertions(+), 45 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index a1780f2..87ffbca 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -107,28 +107,30 @@ def get_all_users(self, admin_token): """Get all users""" return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) - def get_locked_users(self, kwargs): + def get_locked_users(self, admin_token): """Get locked users""" - return self.request_session.get(generate_full_url(Endpoints.locked_users), params = kwargs) + return self.request_session.get(generate_full_url(Endpoints.locked_users), + params = {"token": admin_token}) - def get_locked_admins(self, kwargs): + def get_locked_admins(self, admin_token): """Get locked admins""" - return self.request_session.get(generate_full_url(Endpoints.locked_admins), params = kwargs) + return self.request_session.get(generate_full_url(Endpoints.locked_admins), + params = {"token": admin_token}) - def lock_user(self, user_to_lock, admin_token): + def lock_user(self, admin_token, user_to_lock): """Lock user by manual command""" return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), - params= {"token": admin_token}) + params= {"token": admin_token, 'name': user_to_lock}) - def unlock_all_users(self, kwargs): + def unlock_all_users(self, admin_token): """Unlock all users""" return self.request_session.put(generate_full_url(Endpoints.locked_reset), params= {"token": admin_token}) - def unlock_user(self, user_to_lock, kwargs): + def unlock_user(self, admin_token, user_to_unlock): """Unlock user by manual command""" - return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_lock), - params=kwargs) + return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_unlock), + params={"token": admin_token, 'name': user_to_unlock}) def tearDown(self): """Define close request session and reset API data @@ -136,6 +138,13 @@ def tearDown(self): self.request_session.get(generate_full_url(Endpoints.reset)) self.request_session.close() + def create_new_user(self, adminToken, newName, newPassword, adminRights): + """Create new user""" + return self.request_session.post(generate_full_url(Endpoints.user), + {"token": adminToken, "name": newName, + "password": newPassword, + "rights": adminRights}) + class Ascertains(unittest.TestCase): """Class for ascertains""" @@ -195,10 +204,7 @@ def check_status_code_200(self, status_code: int): # def logout(self, name: str, token: str): # return self.request_session.post(generate_full_url(Endpoints.logout), {"name": name, "token": token}) # -# def create_new_user(self, adminToken, newName, newPassword, adminRights): -# return self.request_session.post(generate_full_url(Endpoints.user), -# {"token": adminToken, "name": newName, "password": newPassword, -# "rights": adminRights}) +# # # def tearDown(self): # return self.request_session.get(generate_full_url(Endpoints.reset)) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index aae7388..6718c3b 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -23,13 +23,13 @@ def tearDown(self): requests.get(generate_full_url(Endpoints.reset)) def test_locked(self): - """Test functionality of locking users""" + """Test functionality of locking user""" users = InitUsers.users.copy() user = choice(list(users.keys())) # returning random user wrong_password = Users.fake_password for _ in range(3): self.login(user, wrong_password) - locked_users_request = self.get_locked_users(self.kwargs) + locked_users_request = self.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] self.assertIn(user, locked_users) @@ -40,7 +40,7 @@ def test_not_locked(self): wrong_passwords = ['', 'password'] for wrong_password in wrong_passwords: self.login(user, wrong_password) - locked_users_request = self.get_locked_users(self.kwargs) + locked_users_request = self.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] self.assertNotIn(user, locked_users) @@ -48,10 +48,9 @@ def test_manual_lock(self): """Test functionality of locking users by manual command""" users = InitUsers.users.copy() user_to_lock = choice(list(users.keys())) # returning random user - self.kwargs['name'] = user_to_lock - self.lock_user(user_to_lock, self.kwargs) - locked_users_request1 = self.get_locked_users(self.kwargs) - self.assertIn(user_to_lock, locked_users_request1.text) + self.lock_user(self.admin_token, user_to_lock) + locked_users_request = self.get_locked_users(self.admin_token) + self.assertIn(user_to_lock, locked_users_request.text) def test_manual_unlock(self): """Test functionality of unlocking users by manual command""" @@ -60,21 +59,19 @@ def test_manual_unlock(self): wrong_password = Users.fake_password for _ in range(3): self.login(user_to_lock, wrong_password) - self.kwargs['name'] = user_to_lock - self.unlock_user(user_to_lock, self.kwargs) - locked_users_request = self.get_locked_users(self.kwargs) + self.unlock_user(self.admin_token, user_to_lock) + locked_users_request = self.get_locked_users(self.admin_token) locked_users = locked_users_request.text self.assertNotIn(user_to_lock, locked_users) def test_reset_locked_admin_token(self): """Test functionality of unlocking all users with admin token""" - # passwords = ['', 'password', 'birthday'] # number of passwords determines login attemps users = InitUsers.users.copy() wrong_password = Users.fake_password for user in users.keys(): self.login(user, wrong_password) - self.unlock_all_users(self.kwargs) - locked_users_request = self.get_locked_users(self.kwargs) + self.unlock_all_users(self.admin_token) + locked_users_request = self.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') @@ -94,7 +91,7 @@ def test_locked_admins(self): wrong_password = Users.fake_password for _ in range(3): self.login(new_user_name, wrong_password) - locked_admins = self.get_locked_admins(self.kwargs) + locked_admins = self.get_locked_admins(self.admin_token) self.assertIn(new_user_name, locked_admins.text) def test_not_locked_admin(self): @@ -105,8 +102,8 @@ def test_not_locked_admin(self): passwords = ['', 'password', new_user_pass] for password in passwords: self.login(new_user_name, password) - locked_admins = self.get_locked_admins(self.kwargs) - logined_admins = self.get_logined_admins(self.kwargs) + locked_admins = self.get_locked_admins(self.admin_token) + logined_admins = self.login_admins(self.admin_token) self.assertNotIn(new_user_name, locked_admins.text) self.assertIn(new_user_name, logined_admins.text) @@ -117,10 +114,9 @@ def test_manual_lock_user_token(self): user_to_lock = choice(list(users.keys())) # returning random user for lock login_for_token = self.login(user, password) token = login_for_token.json()['content'] - fake_kwargs = {'token': token, 'name': user_to_lock} - self.lock_user(user_to_lock, fake_kwargs) - locked_users_request1 = self.get_locked_users(self.kwargs) - self.assertNotIn(user_to_lock, locked_users_request1.text) + self.lock_user(token, user_to_lock) + locked_users_request = self.get_locked_users(self.admin_token) + self.assertNotIn(user_to_lock, locked_users_request.text) def test_locking_unexisting_user(self): """Test functionality of locking unexisting users""" @@ -128,9 +124,8 @@ def test_locking_unexisting_user(self): fake_password = Users.fake_password for _ in range(3): self.login(fake_user, fake_password) - locked_users_request = self.get_locked_users(self.kwargs) + locked_users_request = self.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] - print(repr(locked_users)) self.assertEqual(locked_users, '') def test_get_locked_admins_user_token(self): @@ -140,9 +135,8 @@ def test_get_locked_admins_user_token(self): for _ in range(3): self.login(DefaultUser.user_admin, Users.fake_password) # locking admin login_for_token = self.login(user, password) - token = login_for_token.json()['content'] - self.kwargs['token'] = token - locked_admins_request = self.get_locked_admins(self.kwargs) + user_token = login_for_token.json()['content'] + locked_admins_request = self.get_locked_admins(user_token) locked_admin = locked_admins_request.json()['content'] self.assertEqual(locked_admin, '') @@ -150,8 +144,8 @@ def test_get_locked_admins_empty_token(self): """Discovering locked admins with empty token""" for _ in range(3): self.login(DefaultUser.user_admin, Users.fake_password) - self.kwargs['token'] = '' - locked_admins_request = self.get_locked_admins(self.kwargs) + token = '' + locked_admins_request = self.get_locked_admins(token) locked_admin = locked_admins_request.json()['content'] self.assertEqual(locked_admin, '') @@ -164,8 +158,7 @@ def test_get_locked_users_user_token(self): user_token = login_for_user_token.json()['content'] user_to_lock = list(users.keys())[0] self.login(user_to_lock, Users.fake_password) - self.kwargs['token'] = user_token - locked_users_request = self.get_locked_users(self.kwargs) + locked_users_request = self.get_locked_users(user_token) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') @@ -176,7 +169,7 @@ def test_get_locked_users_empty_token(self): user_to_lock = list(users.keys())[0] for _ in range(3): self.login(user_to_lock, Users.fake_password) - self.kwargs['token'] = '' - locked_users_request = self.get_locked_users(self.kwargs) + token = '' + locked_users_request = self.get_locked_users(token) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') From 1d6e6d5da6e608fca579a37dca06048b32a1b5f0 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Thu, 1 Nov 2018 14:34:21 +0200 Subject: [PATCH 58/74] added @ddt to repetable tests --- requirements.pip | 3 +- tests/constants/constants.py | 14 +- tests/functional/tests_get_user_name.py | 2 +- tests/functional/tests_user_change_pass.py | 133 ++--------- tests/functional/tests_user_create_new.py | 250 ++------------------- 5 files changed, 32 insertions(+), 370 deletions(-) diff --git a/requirements.pip b/requirements.pip index d0829e3..2216f50 100644 --- a/requirements.pip +++ b/requirements.pip @@ -1,4 +1,5 @@ pycodestyle==2.4.0 requests==2.20.0 nose==1.3.7 -pylint==2.1.1 \ No newline at end of file +pylint==2.1.1 +ddt==1.2.0 \ No newline at end of file diff --git a/tests/constants/constants.py b/tests/constants/constants.py index be64919..0169f99 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -61,19 +61,9 @@ class NewUser: class InvalidValues: """Invalid values for login and passwords""" + values = ("qwerty ", " ", "", "!@#$%^&*()><", "ываываыва", "ÆðÆðÆðÆð", + "本本本本", "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555", "k") - values = { - 0: "qwerty ", - 1: " ", - 2: "", - 3: "!@#$%^&*()><", - 4: "ываываыва", - 5: "ÆðÆðÆðÆð", - 6: "本本本本", - 7: "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555" - "55555555555555555555555555555555555555555555555555555555555555555555", - 8: "k" - } class BaseUrl: diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py index ed8d452..b9d5cf1 100644 --- a/tests/functional/tests_get_user_name.py +++ b/tests/functional/tests_get_user_name.py @@ -32,4 +32,4 @@ def test_invalid_token(self): response = self.get_user_name(wrong_token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) - self.assertEqual(UserToTest.login, returned_user_name) + self.assertEqual("", returned_user_name) diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py index 1f0c66b..8533d96 100644 --- a/tests/functional/tests_user_change_pass.py +++ b/tests/functional/tests_user_change_pass.py @@ -3,8 +3,10 @@ from tests.constants.constants import UserToTest, InvalidValues from tests.functional import ApiTestBase +from ddt import ddt, idata +@ddt class TestChangePass(ApiTestBase): """Testing server for ability to change pass with valid data and not valid data""" @@ -20,137 +22,28 @@ def test_change_pass_valid_data(self): """Change pass with valid data""" # change pass - valid_pass = UserToTest.password - change_pass = self.change_pass(self.token, UserToTest.password, valid_pass) + new_pass = UserToTest.password + "wk" + change_pass = self.change_pass(self.token, UserToTest.password, new_pass) self.assertEqual(200, change_pass.status_code) self.assertTrue(change_pass.text) # login with changed pass - login_with_new_pass = self.login(UserToTest.login, valid_pass) + login_with_new_pass = self.login(UserToTest.login, new_pass) len_token = len(login_with_new_pass.json()['content']) self.assertEqual(200, login_with_new_pass.status_code) self.assertEqual(32, len_token) - def test_add_space_to_the_new_pass(self): - """add 1 space to the new pass""" + @idata(InvalidValues.values) + def test_change_pass(self, value): + """Change pass with invalid values""" - pass_with_space = InvalidValues.values[0] - change_pass = self.change_pass(self.token, UserToTest.password, pass_with_space) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_with_space) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "New pass contain spaces") - - def test_pass_contain_spaces(self): - """Use spaces only for new pass""" - - pass_only_spaces = InvalidValues.values[1] - change_pass = self.change_pass(self.token, UserToTest.password, pass_only_spaces) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_only_spaces) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "changed pass contain spaces only") - - def test_leave_pass_without_data(self): - """don't enter any data to the new pass""" - - no_pass = InvalidValues.values[2] - change_pass = self.change_pass(self.token, UserToTest.password, no_pass) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, no_pass) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "Pass field was empty") - - def test_enter_symbols(self): - """enter "!@#$%^&*()><" to the new pass""" - - pass_contain_symbols = InvalidValues.values[3] - change_pass = self.change_pass(self.token, UserToTest.password, pass_contain_symbols) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_contain_symbols) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "Pass contain !@#$%^&*()><") - self.assertFalse(login_with_new_pass.text) - - def test_use_cyrillic_letters(self): - """use cyrillic letters in new pass""" - - pass_cyrillic = InvalidValues.values[4] - change_pass = self.change_pass(self.token, UserToTest.password, pass_cyrillic) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_cyrillic) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "Pass contain cyrillic letters") - self.assertFalse(login_with_new_pass.text) - - def test_use_ascii_symbols(self): - """use_ASCII_symbols in new pass""" - - pass_ascii_symbols = InvalidValues.values[5] - change_pass = self.change_pass(self.token, UserToTest.password, pass_ascii_symbols) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_ascii_symbols) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "Pass contain ASCII symbols") - self.assertFalse(login_with_new_pass.text) - - def test_use_japan_language(self): - """use japan world in new pass""" - - pass_japan = InvalidValues.values[6] - change_pass = self.change_pass(self.token, UserToTest.password, pass_japan) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_japan) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "pass contain Japan language") - self.assertFalse(login_with_new_pass.text) - - def test_too_long_pass(self): - """use very long new pass""" - - pass_too_long = InvalidValues.values[7] - change_pass = self.change_pass(self.token, UserToTest.password, pass_too_long) - self.assertEqual(200, change_pass.status_code) - - # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_too_long) - len_token = len(login_with_new_pass.json()['content']) - self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "pass is too long") - self.assertFalse(login_with_new_pass.text) - - def too_short_pass(self): - """user very short pass(only 1 letter)""" - - pass_too_short = InvalidValues.values[8] - change_pass = self.change_pass(self.token, UserToTest.password, pass_too_short) + # change pass + change_pass = self.change_pass(self.token, UserToTest.password, value) self.assertEqual(200, change_pass.status_code) - self.assertFalse(change_pass.text,) + self.assertTrue(change_pass.text) # login with changed pass - login_with_new_pass = self.login(UserToTest.login, pass_too_short) + login_with_new_pass = self.login(UserToTest.login, value) len_token = len(login_with_new_pass.json()['content']) self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "pass is too short") - self.assertFalse(login_with_new_pass.text) + self.assertNotEqual(32, len_token, "Pass changed to wrong: " + value) diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index d352a05..423dcf0 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -3,8 +3,10 @@ from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser, NewUser, UserToTest, InvalidValues +from ddt import ddt, idata +@ddt class TestCreateNewUser(ApiTestBase): """Create new user with valid and invalid data""" @@ -26,7 +28,7 @@ def test_create_new_user(self): # try to login with new user login = self.login(NewUser.name, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, create_new_user.status_code) + self.assertEqual(200, login.status_code) self.assertEqual(32, len_of_new_user_token) def test_create_new_with_exist_name(self): @@ -72,254 +74,30 @@ def test_give_invalid_admin_rights(self): text_of_login_message = str(login.content) self.assertIn("ERROR", text_of_login_message, "User was created with invalid admin rights") - def test_add_spaces_to_login(self): + @idata(InvalidValues.values) + def test_wrong_new_login(self, value): """create new user with spaces on login""" - login_with_space = InvalidValues.values[0] - create_new_user = self.create_new_user(self.admin_token, login_with_space, NewUser.password, NewUser.isUser) + # login_with_space = InvalidValues.values[0] + create_new_user = self.create_new_user(self.admin_token, value, NewUser.password, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) # try to login with new user - login = self.login(login_with_space, NewUser.password) + login = self.login(value, NewUser.password) len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces in login!") + self.assertNotEqual(32, len_of_new_user_token, "Wrong login name: " + value) - def test_login_contain_only_spaces(self): + @idata(InvalidValues.values) + def test_wrong_new_pass(self, value): """create new user with only spaces on login""" - login_spaces_only = InvalidValues.values[1] - create_new_user = self.create_new_user(self.admin_token, login_spaces_only, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(login_spaces_only, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces only in login!") - - def test_login_is_empty(self): - """create new user with empty login """ - - login_empty = InvalidValues.values[2] - create_new_user = self.create_new_user(self.admin_token, login_empty, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login("", NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with empty login!") - - def test_login_contain_symbols(self): - """Login contain !@#$%^&*()<> """ - - login_symbols = InvalidValues.values[3] - create_new_user = self.create_new_user(self.admin_token, login_symbols, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(login_symbols, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with !@#$%^&*()<> in login!") - - def test_login_contain_cyrillic_letters(self): - """Login contain cyrillic letters""" - - login_cyrillic = InvalidValues.values[4] - create_new_user = self.create_new_user(self.admin_token, login_cyrillic, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(login_cyrillic, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with cyrillic letters in login") - - def test_login_contain_ascii_symbols(self): - """Login contain ASCII symbols""" - - login_ascii = InvalidValues.values[5] - create_new_user = self.create_new_user(self.admin_token, login_ascii, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(login_ascii, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "ERROR. New user was created with ASCII symbols in login") - - def test_login_contain_japan_symbols(self): - - """Login contain Japan symbols""" - - login_japan = InvalidValues.values[6] - create_new_user = self.create_new_user(self.admin_token, login_japan, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(login_japan, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with Japan symbols in login") - - def test_login_is_too_long(self): - - """Login is too long""" - - login_too_long = InvalidValues.values[7] - create_new_user = self.create_new_user(self.admin_token, login_too_long, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(login_too_long, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, " User was created with too long login") - - def test_login_is_too_short(self): - """Login is too short""" - - login_too_short = InvalidValues.values[8] - create_new_user = self.create_new_user(self.admin_token, login_too_short, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(login_too_short, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, " User was created with too short login") - - def test_pass_contain_spaces(self): - """Pass contain spaces""" - - pass_with_spaces = InvalidValues.values[0] - create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_with_spaces, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(NewUser.name, pass_with_spaces) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces in password") - - def test_pass_contain_only_spaces(self): - """Pass contain spaces only""" - - pass_spaces_only = InvalidValues.values[1] - create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_spaces_only, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(NewUser.name, pass_spaces_only) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with spaces only in password!") - - def test_pass_is_empty(self): - """create new user with empty pass""" - - pass_empty = InvalidValues.values[2] - create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_empty, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(NewUser.name, pass_empty) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with empty pass!") - - def test_pass_contain_symbols(self): - """Pass contain !@#$%^&*()<> """ - - pass_symbols = InvalidValues.values[3] - create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_symbols, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(NewUser.name, pass_symbols) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with !@#$%^&*()<> in password") - - def test_pass_contain_cyrillic_letters(self): - """Pass contain cyrillic letters""" - - pass_cyrillic = InvalidValues.values[4] - create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_cyrillic, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(NewUser.name, pass_cyrillic) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with cyrillic letters in password") - - def test_pass_contain_ascii_symbols(self): - """Login contain ASCII symbols""" - - pass_ascii = InvalidValues.values[5] - create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_ascii, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(NewUser.name, pass_ascii) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with ASCII symbols in password") - - def test_pass_contain_Japan_symbols(self): - """pass contain Japan symbols""" - - pass_japan = InvalidValues.values[6] - create_new_user = self.create_new_user(self.admin_token, NewUser.name, pass_japan, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(NewUser.name, pass_japan) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with Japan symbols in pass") - - def test_pass_is_too_long(self): - """Password is too long""" - - pass_too_long = InvalidValues.values[7] - create_new_user = self.create_new_user(self.admin_token, pass_too_long, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) - self.assertEqual(200, create_new_user.status_code) - - # try to login with new user - login = self.login(pass_too_long, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with too long password") - - def test_pass_is_too_short(self): - """Password is too short""" - - pass_too_short = InvalidValues.values[8] - create_new_user = self.create_new_user(self.admin_token, pass_too_short, NewUser.password, NewUser.isUser) + create_new_user = self.create_new_user(self.admin_token, NewUser.name, value, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) # try to login with new user - login = self.login(pass_too_short, NewUser.password) + login = self.login(NewUser.name, value) len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with too long password") + self.assertNotEqual(32, len_of_new_user_token, "User was created with wrong pass: " + value) From 8cae6cf09b34e0362a6d95be08eac6e332eeb23e Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Thu, 1 Nov 2018 14:48:25 +0200 Subject: [PATCH 59/74] pyling --- tests/constants/constants.py | 2 +- tests/functional/tests_user_create_new.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index 0169f99..7911203 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -62,7 +62,7 @@ class NewUser: class InvalidValues: """Invalid values for login and passwords""" values = ("qwerty ", " ", "", "!@#$%^&*()><", "ываываыва", "ÆðÆðÆðÆð", - "本本本本", "5555555555555555555555555555555555555555555555555555555555555555555555555555555555555555", "k") + "本本本本", "555555555555555555555555555555555555555555555555555555555555555555555555555555555", "k") diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index 423dcf0..e0f19b1 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -66,7 +66,7 @@ def test_give_invalid_admin_rights(self): create_new_user = self.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.wrong_rights) self.assertIn("Bad Request", create_new_user.text) - self.assertEquals(400, create_new_user.status_code) + self.assertEqual(400, create_new_user.status_code) self.assertNotEqual(200, create_new_user.status_code) # try to login with new user From 7b82d6431a9a797ee5bbd4110351b19fe9489f0c Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Thu, 1 Nov 2018 18:51:04 +0200 Subject: [PATCH 60/74] made the file application when created class Wrapper for all method with __init__ method --- tests/functional/__init__.py | 139 ++-------------------------------- tests/utils/application.py | 141 +++++++++++++++++++++++++++++++++++ 2 files changed, 146 insertions(+), 134 deletions(-) create mode 100644 tests/utils/application.py diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index cbaca1d..74152f8 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -2,151 +2,22 @@ import unittest -import requests -from requests import request - -from tests.constants.constants import Endpoints -from tests.utils.helper import generate_full_url +from tests.utils.application import Wrapper class ApiTestBase(unittest.TestCase): """Main class for testing""" + application = Wrapper() + def setUp(self): """Define open request session that will be executed before each test method.""" - self.request_session = requests.session() + self.application.__init__() def tearDown(self): """Define close request session and reset API data that will be executed after each test method.""" - self.request_session.get(generate_full_url(Endpoints.reset)) - self.request_session.close() - - def reset(self): - """Reset API""" - return self.request_session.get(generate_full_url(Endpoints.reset)) - - def login(self, name: str, password: str) -> request: - """Login user with name and password.""" - return self.request_session.post(generate_full_url(Endpoints.login), - params={"name": name, "password": password}) - - def logout(self, name: str, token: str) -> request: - """Logout user with name and user token.""" - return self.request_session.post(generate_full_url(Endpoints.logout), - params={"name": name, "token": token}) - - def login_admins(self, token: str) -> request: - """Logged admins""" - return self.request_session.get(generate_full_url(Endpoints.login_admins), - params={"token": token}) - - def login_users(self, token: str) -> request: - """Logged users""" - return self.request_session.get(generate_full_url(Endpoints.login_users), - params={"token": token}) - - def login_tockens(self, token: str) -> request: - """Alive tokens""" - return self.request_session.get(generate_full_url(Endpoints.login_tockens), - params={"token": token}) - - def admins(self, token: str) -> request: - """All admins""" - return self.request_session.get(generate_full_url(Endpoints.admins), - params={"token": token}) - - def get_user_all_items(self, user, admin_token): - """Get all user items""" - return self.request_session.get(generate_full_url(Endpoints.item_user).format(name=user), - params={"token": admin_token}) - - def get_user_item_by_index(self, index, user, admin_token): - """Get user item by index""" - return self.request_session.get(generate_full_url(Endpoints.item_user_by_index).format(index=index, name=user), - params={"token": admin_token}) - - def add_item(self, index, token, item): - """Add item""" - return self.request_session.post(generate_full_url(Endpoints.item).format(index=index), - params={"token": token, "item": item}) - - def delete_item(self, index, token): - """Delete item""" - return self.request_session.delete(generate_full_url(Endpoints.item).format(index=index), - params={"token": token}) - - def update_item(self, index, token, item): - """Update item""" - return self.request_session.put(generate_full_url(Endpoints.item).format(index=index), - params={"token": token, "item": item}) - - def get_item(self, index, token): - """Get item by index""" - return self.request_session.get(generate_full_url(Endpoints.item).format(index=index), - params={"token": token}) - - def get_item_indexes(self, token): - """Get all item indexes""" - return self.request_session.get(generate_full_url(Endpoints.itemindexes), params={"token": token}) - - def get_all_items(self, token): - """Get all items by user""" - return self.request_session.get(generate_full_url(Endpoints.items), params={"token": token}) - - def change_cool_down_time(self, admin_token, new_value): - """Change cool down time""" - return self.request_session.put(generate_full_url(Endpoints.cooldowntime), - params={"token": admin_token, "time": new_value}) - - def get_cool_down_time(self): - """Get cool down time""" - return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) - - def change_token_life_time(self, admin_token, new_value): - """Change token life time""" - return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), - params={"token": admin_token, "time": new_value}) - - def get_token_life_time(self): - """Get token life time""" - return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) - - def get_all_users(self, admin_token): - """Get all users""" - return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) - - def get_locked_users(self, admin_token): - """Get locked users""" - return self.request_session.get(generate_full_url(Endpoints.locked_users), - params={"token": admin_token}) - - def get_locked_admins(self, admin_token): - """Get locked admins""" - return self.request_session.get(generate_full_url(Endpoints.locked_admins), - params={"token": admin_token}) - - def lock_user(self, admin_token, user_to_lock): - """Lock user by manual command""" - return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), - params={"token": admin_token, 'name': user_to_lock}) - - def unlock_all_users(self, admin_token): - """Unlock all users""" - return self.request_session.put(generate_full_url(Endpoints.locked_reset), - params={"token": admin_token}) - - def unlock_user(self, admin_token, user_to_unlock): - """Unlock user by manual command""" - return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_unlock), - params={"token": admin_token, 'name': user_to_unlock}) - - def create_new_user(self, admin_token, new_name, new_password, admin_rights): - """Create new user""" - return self.request_session.post(generate_full_url(Endpoints.user), - {"token": admin_token, "name": new_name, - "password": new_password, - "rights": admin_rights}) + self.application.__del__() class Ascertains(unittest.TestCase): diff --git a/tests/utils/application.py b/tests/utils/application.py new file mode 100644 index 0000000..40ef058 --- /dev/null +++ b/tests/utils/application.py @@ -0,0 +1,141 @@ +import requests +from requests import request + +from tests.constants.constants import Endpoints +from tests.utils.helper import generate_full_url + + +class Wrapper: + + def __init__(self): + self.request_session = requests.session() + self.request_session.close() + + def reset(self): + """Reset API""" + return self.request_session.get(generate_full_url(Endpoints.reset)) + + def login(self, name: str, password: str) -> request: + """Login user with name and password.""" + return self.request_session.post(generate_full_url(Endpoints.login), + params={"name": name, "password": password}) + + def logout(self, name: str, token: str) -> request: + """Logout user with name and user token.""" + return self.request_session.post(generate_full_url(Endpoints.logout), + params={"name": name, "token": token}) + + def login_admins(self, token: str) -> request: + """Logged admins""" + return self.request_session.get(generate_full_url(Endpoints.login_admins), + params={"token": token}) + + def login_users(self, token: str) -> request: + """Logged users""" + return self.request_session.get(generate_full_url(Endpoints.login_users), + params={"token": token}) + + def login_tockens(self, token: str) -> request: + """Alive tokens""" + return self.request_session.get(generate_full_url(Endpoints.login_tockens), + params={"token": token}) + + def admins(self, token: str) -> request: + """All admins""" + return self.request_session.get(generate_full_url(Endpoints.admins), + params={"token": token}) + + def get_user_all_items(self, user, admin_token): + """Get all user items""" + return self.request_session.get(generate_full_url(Endpoints.item_user).format(name=user), + params={"token": admin_token}) + + def get_user_item_by_index(self, index, user, admin_token): + """Get user item by index""" + return self.request_session.get(generate_full_url(Endpoints.item_user_by_index).format(index=index, name=user), + params={"token": admin_token}) + + def add_item(self, index, token, item): + """Add item""" + return self.request_session.post(generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def delete_item(self, index, token): + """Delete item""" + return self.request_session.delete(generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def update_item(self, index, token, item): + """Update item""" + return self.request_session.put(generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def get_item(self, index, token): + """Get item by index""" + return self.request_session.get(generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def get_item_indexes(self, token): + """Get all item indexes""" + return self.request_session.get(generate_full_url(Endpoints.itemindexes), params={"token": token}) + + def get_all_items(self, token): + """Get all items by user""" + return self.request_session.get(generate_full_url(Endpoints.items), params={"token": token}) + + def change_cool_down_time(self, admin_token, new_value): + """Change cool down time""" + return self.request_session.put(generate_full_url(Endpoints.cooldowntime), + params={"token": admin_token, "time": new_value}) + + def get_cool_down_time(self): + """Get cool down time""" + return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) + + def change_token_life_time(self, admin_token, new_value): + """Change token life time""" + return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), + params={"token": admin_token, "time": new_value}) + + def get_token_life_time(self): + """Get token life time""" + return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) + + def get_all_users(self, admin_token): + """Get all users""" + return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) + + def get_locked_users(self, admin_token): + """Get locked users""" + return self.request_session.get(generate_full_url(Endpoints.locked_users), + params={"token": admin_token}) + + def get_locked_admins(self, admin_token): + """Get locked admins""" + return self.request_session.get(generate_full_url(Endpoints.locked_admins), + params={"token": admin_token}) + + def lock_user(self, admin_token, user_to_lock): + """Lock user by manual command""" + return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), + params={"token": admin_token, 'name': user_to_lock}) + + def unlock_all_users(self, admin_token): + """Unlock all users""" + return self.request_session.put(generate_full_url(Endpoints.locked_reset), + params={"token": admin_token}) + + def unlock_user(self, admin_token, user_to_unlock): + """Unlock user by manual command""" + return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_unlock), + params={"token": admin_token, 'name': user_to_unlock}) + + def create_new_user(self, admin_token, new_name, new_password, admin_rights): + """Create new user""" + return self.request_session.post(generate_full_url(Endpoints.user), + {"token": admin_token, "name": new_name, + "password": new_password, + "rights": admin_rights}) + + def __del__(self): + self.request_session.close() From 647c0db98c3b8dbe410458125994b5e04800ce80 Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Thu, 1 Nov 2018 20:29:15 +0200 Subject: [PATCH 61/74] the new file application, changes the file __init__ of the functional, for example look file tests_login. It is the new architecture, when logic exists separately tests --- tests/application/__init__.py | 0 tests/application/application.py | 160 +++++++++++++++++++++++++++++++ tests/functional/__init__.py | 13 ++- tests/functional/tests_admins.py | 4 +- tests/functional/tests_login.py | 46 ++++----- tests/functional/tests_logout.py | 4 +- tests/utils/helper.py | 6 -- 7 files changed, 193 insertions(+), 40 deletions(-) create mode 100644 tests/application/__init__.py create mode 100644 tests/application/application.py diff --git a/tests/application/__init__.py b/tests/application/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/application/application.py b/tests/application/application.py new file mode 100644 index 0000000..3d1aa58 --- /dev/null +++ b/tests/application/application.py @@ -0,0 +1,160 @@ +import requests +from requests import request + +from tests.constants.constants import Endpoints + + +class ApiWrapper: + + def __init__(self, app_url): + self.request_session = requests.session() + self.base_url = app_url + + def __del__(self): + self.request_session.close() + + def _generate_full_url(self, path): + """Generate the full url with base url and path""" + return "{}{}".format(self.base_url, path) + + def reset(self): + """Reset API""" + return self.request_session.get(self._generate_full_url(Endpoints.reset)) + + def login(self, name: str, password: str) -> request: + """Login user with name and password.""" + return self.request_session.post(self._generate_full_url(Endpoints.login), + params={"name": name, "password": password}) + + def logout(self, name: str, token: str) -> request: + """Logout user with name and user token.""" + return self.request_session.post(self._generate_full_url(Endpoints.logout), + params={"name": name, "token": token}) + + def login_admins(self, token: str) -> request: + """Logged admins""" + return self.request_session.get(self._generate_full_url(Endpoints.login_admins), + params={"token": token}) + + def login_users(self, token: str) -> request: + """Logged users""" + return self.request_session.get(self._generate_full_url(Endpoints.login_users), + params={"token": token}) + + def login_tockens(self, token: str) -> request: + """Alive tokens""" + return self.request_session.get(self._generate_full_url(Endpoints.login_tockens), + params={"token": token}) + + def admins(self, token: str) -> request: + """All admins""" + return self.request_session.get(self._generate_full_url(Endpoints.admins), + params={"token": token}) + + def get_user_all_items(self, user, admin_token): + """Get all user items""" + return self.request_session.get(self._generate_full_url(Endpoints.item_user).format(name=user), + params={"token": admin_token}) + + def get_user_item_by_index(self, index, user, admin_token): + """Get user item by index""" + return self.request_session.get(self._generate_full_url(Endpoints.item_user_by_index).format(index=index, + name=user), + params={"token": admin_token}) + + def add_item(self, index, token, item): + """Add item""" + return self.request_session.post(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def delete_item(self, index, token): + """Delete item""" + return self.request_session.delete(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def update_item(self, index, token, item): + """Update item""" + return self.request_session.put(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def get_item(self, index, token): + """Get item by index""" + return self.request_session.get(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def get_item_indexes(self, token): + """Get all item indexes""" + return self.request_session.get(self._generate_full_url(Endpoints.itemindexes), params={"token": token}) + + def get_all_items(self, token): + """Get all items by user""" + return self.request_session.get(self._generate_full_url(Endpoints.items), params={"token": token}) + + def change_cool_down_time(self, admin_token, new_value): + """Change cool down time""" + return self.request_session.put(self._generate_full_url(Endpoints.cooldowntime), + params={"token": admin_token, "time": new_value}) + + def get_cool_down_time(self): + """Get cool down time""" + return self.request_session.get(self._generate_full_url(Endpoints.cooldowntime)) + + def change_token_life_time(self, admin_token, new_value): + """Change token life time""" + return self.request_session.put(self._generate_full_url(Endpoints.tokenlifetime), + params={"token": admin_token, "time": new_value}) + + def get_token_life_time(self): + """Get token life time""" + return self.request_session.get(self._generate_full_url(Endpoints.tokenlifetime)) + + def get_all_users(self, admin_token): + """Get all users""" + return self.request_session.get(self._generate_full_url(Endpoints.users), params={"token": admin_token}) + + def get_locked_users(self, admin_token): + """Get locked users""" + return self.request_session.get(self._generate_full_url(Endpoints.locked_users), + params={"token": admin_token}) + + def get_locked_admins(self, admin_token): + """Get locked admins""" + return self.request_session.get(self._generate_full_url(Endpoints.locked_admins), + params={"token": admin_token}) + + def lock_user(self, admin_token, user_to_lock): + """Lock user by manual command""" + return self.request_session.post((self._generate_full_url(Endpoints.locked_user) + user_to_lock), + params={"token": admin_token, 'name': user_to_lock}) + + def unlock_all_users(self, admin_token): + """Unlock all users""" + return self.request_session.put(self._generate_full_url(Endpoints.locked_reset), + params={"token": admin_token}) + + def unlock_user(self, admin_token, user_to_unlock): + """Unlock user by manual command""" + return self.request_session.put((self._generate_full_url(Endpoints.locked_user) + user_to_unlock), + params={"token": admin_token, 'name': user_to_unlock}) + + def create_new_user(self, admin_token, new_name, new_password, admin_rights): + """Create new user""" + return self.request_session.post(self._generate_full_url(Endpoints.user), + {"token": admin_token, "name": new_name, + "password": new_password, + "rights": admin_rights}) + + def change_pass(self, token, old_password, new_password): + """change pass""" + return self.request_session.put(self._generate_full_url(Endpoints.user), {"token": token, + "oldpassword": old_password, + "newpassword": new_password}) + + def get_user_name(self, token): + """get user name of logged user""" + return self.request_session.get(self._generate_full_url(Endpoints.user), params={"token": token}) + + def delete_user(self, admin_token, name): + """delete user""" + return self.request_session.delete(self._generate_full_url(Endpoints.user), params={"token": admin_token, + "name": name}) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 74152f8..bed54ac 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -2,26 +2,25 @@ import unittest -from tests.utils.application import Wrapper +from tests.application.application import ApiWrapper +from tests.constants.constants import BaseUrl class ApiTestBase(unittest.TestCase): """Main class for testing""" - application = Wrapper() - def setUp(self): """Define open request session that will be executed before each test method.""" - self.application.__init__() + self.application = ApiWrapper(BaseUrl.base_url) def tearDown(self): """Define close request session and reset API data that will be executed after each test method.""" - self.application.__del__() + del self.application -class Ascertains(unittest.TestCase): - """Class for ascertains""" +class Assertions(unittest.TestCase): + """Class for Assertions""" def check_status_code_200(self, status_code: int): """Check if response status code is valid""" diff --git a/tests/functional/tests_admins.py b/tests/functional/tests_admins.py index 06dcc61..9be8181 100644 --- a/tests/functional/tests_admins.py +++ b/tests/functional/tests_admins.py @@ -1,10 +1,10 @@ """Functional tests for admins""" from tests.constants.constants import Users, DefaultUser, DefaultToken -from tests.functional import ApiTestBase, Ascertains +from tests.functional import ApiTestBase, Assertions -class TestAdmins(ApiTestBase, Ascertains): +class TestAdmins(ApiTestBase, Assertions): """Class for testing""" def test_admins(self): diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py index 26197f3..1617ed7 100644 --- a/tests/functional/tests_login.py +++ b/tests/functional/tests_login.py @@ -1,101 +1,101 @@ """Functional tests for logging users""" from tests.constants.constants import DefaultUser, Users, DefaultToken -from tests.functional import ApiTestBase, Ascertains +from tests.functional import ApiTestBase, Assertions -class TestLogin(ApiTestBase, Ascertains): +class TestLogin(ApiTestBase, Assertions): """Class for testing""" def test_login(self): """Login user. If user got token test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) + login = self.application.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) self.assertEqual(len(login.json().get("content")), 32, "Invalid token") def test_login_user_not_found(self): """Login fake user name. If user not found test pass.""" - login = self.login(Users.fake_user, Users.fake_password) + login = self.application.login(Users.fake_user, Users.fake_password) self.check_status_code_200(login.status_code) self.assertIn("ERROR, user not found", login.text, "User founded") def test_login_user_locked(self): """Login 4 times with fake password to lock. If user locked test pass.""" for _ in range(4): - login = self.login(Users.valid_user, Users.fake_password) + login = self.application.login(Users.valid_user, Users.fake_password) self.check_status_code_200(login.status_code) - self.assertIn("ERROR, user locked", login.text, "User not locked") + self.assertIn("ERROR, user locked", login.text, "User not locked") def test_login_fake_user_locked(self): """Login 4 times with fake user to lock. If user not found test pass.""" for _ in range(4): - login = self.login(Users.fake_user, Users.fake_password) + login = self.application.login(Users.fake_user, Users.fake_password) self.check_status_code_200(login.status_code) - self.assertIn("ERROR, user not found", login.text, "User locked") + self.assertIn("ERROR, user not found", login.text, "User locked") def test_login_admins(self): """Get logged admins with admin token. If user had admin rights and got the list of logged admins test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) + login = self.application.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) - logged_admins = self.login_admins(login.json().get("content")) + logged_admins = self.application.login_admins(login.json().get("content")) self.check_status_code_200(logged_admins.status_code) self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_admins_user(self): """Get logged admins without admin token. If empty response test pass.""" - login = self.login(Users.valid_user, Users.valid_password) + login = self.application.login(Users.valid_user, Users.valid_password) self.check_status_code_200(login.status_code) - logged_admins = self.login_admins(login.json().get("content")) + logged_admins = self.application.login_admins(login.json().get("content")) self.check_status_code_200(logged_admins.status_code) self.assertFalse(logged_admins.json().get("content"), "Content is not empty") def test_login_admins_default_token(self): """Get logged admins with default token. If empty response test pass.""" - logged_admins = self.login_admins(DefaultToken.token) + logged_admins = self.application.login_admins(DefaultToken.token) self.check_status_code_200(logged_admins.status_code) self.assertFalse(logged_admins.json().get("content"), "Content is not empty") def test_login_users_admin(self): """Get logged users with admin token. If got the list of logged users test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) + login = self.application.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) - logged_admins = self.login_users(login.json().get("content")) + logged_admins = self.application.login_users(login.json().get("content")) self.check_status_code_200(logged_admins.status_code) self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_users(self): """Get logged users without admin token. If list of users empty test pass.""" - login = self.login(Users.valid_user, Users.valid_password) + login = self.application.login(Users.valid_user, Users.valid_password) self.check_status_code_200(login.status_code) - logged_users = self.login_users(login.json().get("content")) + logged_users = self.application.login_users(login.json().get("content")) self.check_status_code_200(logged_users.status_code) self.assertFalse(logged_users.json().get("content"), "Content is not empty") def test_login_users_default_token(self): """Get logged users without admin token. If list of users empty test pass.""" - logged_users = self.login_users(DefaultToken.token) + logged_users = self.application.login_users(DefaultToken.token) self.check_status_code_200(logged_users.status_code) self.assertFalse(logged_users.json().get("content"), "Content is not empty") def test_login_tockens_admin(self): """Get alive tockens with admin token. If got list of tokens test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) + login = self.application.login(DefaultUser.user, DefaultUser.password) self.check_status_code_200(login.status_code) - alive_tokens = self.login_tockens(login.json().get("content")) + alive_tokens = self.application.login_tockens(login.json().get("content")) self.check_status_code_200(alive_tokens.status_code) self.assertTrue(alive_tokens.json().get("content"), "Content is empty") def test_login_tockens_users(self): """Get alive tockens without admin token. If list of tokens empty test pass""" - login = self.login(Users.valid_user, Users.valid_password) + login = self.application.login(Users.valid_user, Users.valid_password) self.check_status_code_200(login.status_code) - alive_tokens = self.login_tockens(login.json().get("content")) + alive_tokens = self.application.login_tockens(login.json().get("content")) self.check_status_code_200(alive_tokens.status_code) self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") def test_login_tockens_users_default_token(self): """Get alive tockens with default token. If list of tokens empty test pass""" - alive_tokens = self.login_tockens(DefaultToken.token) + alive_tokens = self.application.login_tockens(DefaultToken.token) self.check_status_code_200(alive_tokens.status_code) self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_logout.py b/tests/functional/tests_logout.py index 08cab41..7586a9d 100644 --- a/tests/functional/tests_logout.py +++ b/tests/functional/tests_logout.py @@ -1,10 +1,10 @@ """Functional tests for logout users""" from tests.constants.constants import DefaultUser, Users, DefaultToken -from tests.functional import ApiTestBase, Ascertains +from tests.functional import ApiTestBase, Assertions -class TestLogout(ApiTestBase, Ascertains): +class TestLogout(ApiTestBase, Assertions): """Class for testing""" def test_logout(self): diff --git a/tests/utils/helper.py b/tests/utils/helper.py index 6ab2dcc..5fe1578 100644 --- a/tests/utils/helper.py +++ b/tests/utils/helper.py @@ -1,11 +1,5 @@ """Help functions for testing""" -from tests.constants.constants import BaseUrl - - -def generate_full_url(path): - """Generate the full url with base url and path""" - return "{}{}".format(BaseUrl.base_url, path) def get_new_value_different_func(func, new_value, step): """ From 4d1846af90e8244438d22542f1f28551530334b5 Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Thu, 1 Nov 2018 23:41:01 +0200 Subject: [PATCH 62/74] refactoring code --- tests/functional/__init__.py | 2 + tests/functional/tests_add_item.py | 29 +++++------- tests/functional/tests_all_items.py | 29 +++++------- tests/functional/tests_delete_item.py | 27 +++++------ tests/functional/tests_get_all_items_user.py | 45 ++++++++----------- tests/functional/tests_get_item_by_index.py | 31 +++++-------- tests/functional/tests_get_item_indexes.py | 27 +++++------ .../tests_get_user_item_by_index.py | 23 ++++------ tests/functional/tests_update_item.py | 31 +++++-------- 9 files changed, 95 insertions(+), 149 deletions(-) diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index bed54ac..820062d 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -12,10 +12,12 @@ class ApiTestBase(unittest.TestCase): def setUp(self): """Define open request session that will be executed before each test method.""" self.application = ApiWrapper(BaseUrl.base_url) + self.application.reset() def tearDown(self): """Define close request session and reset API data that will be executed after each test method.""" + self.application.reset() del self.application diff --git a/tests/functional/tests_add_item.py b/tests/functional/tests_add_item.py index 607d0c9..9052686 100644 --- a/tests/functional/tests_add_item.py +++ b/tests/functional/tests_add_item.py @@ -1,6 +1,7 @@ """Functional tests for add item""" from random import choice, randint + from tests.functional import ApiTestBase from tests.constants.constants import InitUsers, INVALID_TOKEN, VALID_STATUS_CODE, ITEM_NAMES @@ -12,21 +13,13 @@ class TestAddItem(ApiTestBase): """Class for tests add item""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() - def test_add_item_positive(self): """Test add item with valid token""" counter = 0 for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - add_item_user_response = self.add_item(counter, token, ITEM_NAME) + token = self.application.login(user, password).json()["content"] + add_item_user_response = self.application.add_item(counter, token, ITEM_NAME) counter = counter + 1 self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertTrue(add_item_user_response.json()["content"]) @@ -35,14 +28,14 @@ def test_add_specific_item(self): """Test add item with specific item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - get_item_response = self.get_item(ITEM_INDEX, token) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_response = self.application.get_item(ITEM_INDEX, token) self.assertEqual(ITEM_NAME, get_item_response.json()["content"]) def test_add_item_negative(self): """Test add item with invalid token""" - add_item_user_response = self.add_item(ITEM_INDEX, INVALID_TOKEN, ITEM_NAME) + add_item_user_response = self.application.add_item(ITEM_INDEX, INVALID_TOKEN, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertFalse(add_item_user_response.json()["content"]) @@ -50,15 +43,15 @@ def test_add_item_invalid_index(self): """Test add item when index not int""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - add_item_user_response = self.add_item(ITEM_NAME, token, ITEM_NAME) + token = self.application.login(user, password).json()["content"] + add_item_user_response = self.application.add_item(ITEM_NAME, token, ITEM_NAME) self.assertNotEqual(VALID_STATUS_CODE, add_item_user_response.status_code) def test_add_int_item(self): """Test add item with only number""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - add_item_user_response = self.add_item(ITEM_INDEX, token, ITEM_INDEX) + token = self.application.login(user, password).json()["content"] + add_item_user_response = self.application.add_item(ITEM_INDEX, token, ITEM_INDEX) self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertFalse(add_item_user_response.json()["content"]) diff --git a/tests/functional/tests_all_items.py b/tests/functional/tests_all_items.py index abe6825..bec34d5 100644 --- a/tests/functional/tests_all_items.py +++ b/tests/functional/tests_all_items.py @@ -1,26 +1,19 @@ """Functional tests for all items""" -from tests.functional import ApiTestBase from tests.constants.constants import InitUsers, INVALID_TOKEN, VALID_STATUS_CODE +from tests.functional import ApiTestBase class TestAllItems(ApiTestBase): """Class for tests of all items""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() def test_without_items(self): """Test get all items when user has not any items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - get_all_items_response = self.get_all_items(token) + token = self.application.login(user, password).json()["content"] + get_all_items_response = self.application.get_all_items(token) self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) self.assertFalse(get_all_items_response.json()["content"]) @@ -28,10 +21,10 @@ def test_with_items(self): """Test get all items when user has items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(1, token, "Product") - self.add_item(2, token, "Car") - get_all_items_response = self.get_all_items(token) + token = self.application.login(user, password).json()["content"] + self.application.add_item(1, token, "Product") + self.application.add_item(2, token, "Car") + get_all_items_response = self.application.get_all_items(token) self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) self.assertNotEqual("", get_all_items_response.json()["content"]) self.assertTrue(get_all_items_response.json()["content"]) @@ -40,9 +33,9 @@ def test_items_by_invalid_token(self): """Test get all items with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(1, token, "Product") - self.add_item(2, token, "Car") - get_all_items_response = self.get_all_items(INVALID_TOKEN) + token = self.application.login(user, password).json()["content"] + self.application.add_item(1, token, "Product") + self.application.add_item(2, token, "Car") + get_all_items_response = self.application.get_all_items(INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, get_all_items_response.status_code) self.assertFalse(get_all_items_response.json()["content"]) diff --git a/tests/functional/tests_delete_item.py b/tests/functional/tests_delete_item.py index bd63e33..8b5ce44 100644 --- a/tests/functional/tests_delete_item.py +++ b/tests/functional/tests_delete_item.py @@ -1,8 +1,9 @@ """Functional tests for delete item""" from random import randint, choice -from tests.functional import ApiTestBase + from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN +from tests.functional import ApiTestBase ITEM_NAME = choice(ITEM_NAMES) @@ -12,20 +13,12 @@ class TestDeleteItem(ApiTestBase): """Class for tests of delete item""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() - def test_delete_empty_item(self): """Test delete item when user has not any items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - delete_item_response = self.delete_item(ITEM_INDEX, token) + token = self.application.login(user, password).json()["content"] + delete_item_response = self.application.delete_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) self.assertFalse(delete_item_response.json()["content"]) @@ -33,9 +26,9 @@ def test_delete_item(self): """Test delete item when user has item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - delete_item_response = self.delete_item(ITEM_INDEX, token) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + delete_item_response = self.application.delete_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) self.assertTrue(delete_item_response.json()["content"]) @@ -43,8 +36,8 @@ def test_delete_item_invalid_token(self): """Test delete item with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - delete_item_response = self.delete_item(ITEM_INDEX, INVALID_TOKEN) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + delete_item_response = self.application.delete_item(ITEM_INDEX, INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) self.assertFalse(delete_item_response.json()["content"]) diff --git a/tests/functional/tests_get_all_items_user.py b/tests/functional/tests_get_all_items_user.py index 430ac61..d6fdcef 100644 --- a/tests/functional/tests_get_all_items_user.py +++ b/tests/functional/tests_get_all_items_user.py @@ -1,8 +1,9 @@ """Functional tests for get all items""" from random import choice, randint -from tests.functional import ApiTestBase + from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN +from tests.functional import ApiTestBase ITEM_INDEX = randint(0, 1000) @@ -12,48 +13,40 @@ class TestAllUserItems(ApiTestBase): """Class for tests of get all items""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() - def test_get_items_by_admin(self): - """Test get user items with admintoken""" - admintoken = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + """Test get user items with admin_token""" + admin_token = self.application.login(DefaultUser.user, DefaultUser.password).json()["content"] for user in InitUsers.users: with self.subTest(i=user): - get_items_user_response = self.get_user_all_items(user, admintoken) + get_items_user_response = self.application.get_user_all_items(user, admin_token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) def test_get_items_by_admin_with_invalid_token(self): """Test get items by admin with invalid token""" - self.login(DefaultUser.user, DefaultUser.password) + self.application.login(DefaultUser.user, DefaultUser.password) for user in InitUsers.users: with self.subTest(i=user): - get_items_user_response = self.get_user_all_items(user, INVALID_TOKEN) + get_items_user_response = self.application.get_user_all_items(user, INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) def test_get_added_items_by_admin(self): """Test get added user items by admin""" for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - admin_token = self.login(DefaultUser.user, DefaultUser.password).json()["content"] + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + admin_token = self.application.login(DefaultUser.user, DefaultUser.password).json()["content"] for user in InitUsers.users: with self.subTest(i=user): - get_items_user_response = self.get_user_all_items(user, admin_token) + get_items_user_response = self.application.get_user_all_items(user, admin_token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertTrue(get_items_user_response.json()["content"]) def test_get_items_invalid_user(self): """Test get item invalid user""" - admin_token = self.login(DefaultUser.user, DefaultUser.password).json()["content"] - get_items_user_response = self.get_user_all_items(ITEM_NAME, admin_token) + admin_token = self.application.login(DefaultUser.user, DefaultUser.password).json()["content"] + get_items_user_response = self.application.get_user_all_items(ITEM_NAME, admin_token) self.assertNotEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertIn("Error", get_items_user_response.text) @@ -61,19 +54,19 @@ def test_get_items_by_user(self): """Test get user items with user token""" for user in InitUsers.users: with self.subTest(i=user): - token = self.login("kilinatc", "qwerty").json()["content"] - get_items_user_response = self.get_user_all_items(user, token) + token = self.application.login("kilinatc", "qwerty").json()["content"] + get_items_user_response = self.application.get_user_all_items(user, token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) def test_get_added_items_by_user(self): """Test get added user items by user token""" for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - token = self.login("akinatc", "qwerty").json()["content"] + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + token = self.application.login("kilinatc", "qwerty").json()["content"] for user in InitUsers.users: with self.subTest(i=user): - get_items_user_response = self.get_user_all_items(user, token) + get_items_user_response = self.application.get_user_all_items(user, token) self.assertEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertFalse(get_items_user_response.json()["content"]) diff --git a/tests/functional/tests_get_item_by_index.py b/tests/functional/tests_get_item_by_index.py index afd4407..fc8042b 100644 --- a/tests/functional/tests_get_item_by_index.py +++ b/tests/functional/tests_get_item_by_index.py @@ -1,8 +1,9 @@ """Functional tests for get item by index""" from random import choice, randint -from tests.functional import ApiTestBase + from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN +from tests.functional import ApiTestBase ITEM_INDEX = randint(0, 1000) @@ -12,20 +13,12 @@ class TestGetItemByIndex(ApiTestBase): """Class for tests of get item by index""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() - def test_get_empty_item(self): """Test get item by index when user has not items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - get_item_response = self.get_item(ITEM_INDEX, token) + token = self.application.login(user, password).json()["content"] + get_item_response = self.application.get_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) self.assertFalse(get_item_response.json()["content"]) @@ -33,9 +26,9 @@ def test_get_item(self): """Test get item by index when user has item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - get_item_response = self.get_item(ITEM_INDEX, token) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_response = self.application.get_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) self.assertTrue(get_item_response.json()["content"]) self.assertEqual(ITEM_NAME, get_item_response.json()["content"]) @@ -44,9 +37,9 @@ def test_get_item_index_str(self): """Test get item by index with str index""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - get_item_response = self.get_item("call", token) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_response = self.application.get_item(ITEM_NAME, token) self.assertNotEqual(VALID_STATUS_CODE, get_item_response.status_code) self.assertIn("Bad Request", get_item_response.text) @@ -54,7 +47,7 @@ def test_get_item_index_invalid_token(self): """Test get item by index with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - self.login(user, password) - get_item_response = self.get_item(ITEM_INDEX, INVALID_TOKEN) + self.application.login(user, password) + get_item_response = self.application.get_item(ITEM_INDEX, INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, get_item_response.status_code) self.assertFalse(get_item_response.json()["content"]) diff --git a/tests/functional/tests_get_item_indexes.py b/tests/functional/tests_get_item_indexes.py index 5d6d016..9ce2001 100644 --- a/tests/functional/tests_get_item_indexes.py +++ b/tests/functional/tests_get_item_indexes.py @@ -1,8 +1,9 @@ """Functional tests for get item indexes""" from random import choice, randint -from tests.functional import ApiTestBase + from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN +from tests.functional import ApiTestBase ITEM_NAME = choice(ITEM_NAMES) @@ -12,20 +13,12 @@ class TestGetItemIndexes(ApiTestBase): """Class for tests of get item indexes""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() - def test_get_empty_item_indexes(self): """Test get item indexes when user has not item indexes""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - get_item_indexes_response = self.get_item_indexes(token) + token = self.application.login(user, password).json()["content"] + get_item_indexes_response = self.application.get_item_indexes(token) self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) self.assertFalse(get_item_indexes_response.json()["content"]) @@ -33,9 +26,9 @@ def test_get_item_indexes(self): """Test get item indexes when user has any item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - get_item_indexes_response = self.get_item_indexes(token) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_indexes_response = self.application.get_item_indexes(token) self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) self.assertTrue(get_item_indexes_response.json()["content"]) @@ -43,8 +36,8 @@ def test_get_item_indexes_by_invalid_token(self): """Test get item indexes with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - get_item_indexes_response = self.get_item_indexes(INVALID_TOKEN) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + get_item_indexes_response = self.application.get_item_indexes(INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, get_item_indexes_response.status_code) self.assertFalse(get_item_indexes_response.json()["content"]) diff --git a/tests/functional/tests_get_user_item_by_index.py b/tests/functional/tests_get_user_item_by_index.py index 8e00f02..92df957 100644 --- a/tests/functional/tests_get_user_item_by_index.py +++ b/tests/functional/tests_get_user_item_by_index.py @@ -1,8 +1,9 @@ """Functional tests for get user item by index""" from random import randint -from tests.functional import ApiTestBase + from tests.constants.constants import InitUsers, DefaultUser, VALID_STATUS_CODE, INVALID_TOKEN +from tests.functional import ApiTestBase ITEM_INDEX = randint(0, 1000) @@ -11,19 +12,11 @@ class TestUserItemByIndex(ApiTestBase): """Class for tests of get user item by index""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() - def test_get_user_item_by_admin(self): """Test get user item by index with admin token""" for user in dict.keys(InitUsers.users): - admin_token = self.login(DefaultUser.user, DefaultUser.password).json()["content"] - get_item_user_response = self.get_user_item_by_index(ITEM_INDEX, user, admin_token) + admin_token = self.application.login(DefaultUser.user, DefaultUser.password).json()["content"] + get_item_user_response = self.application.get_user_item_by_index(ITEM_INDEX, user, admin_token) self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertFalse(get_item_user_response.json()["content"]) @@ -31,8 +24,8 @@ def test_get_user_item_by_user(self): """Test get user item by index with user token""" counter = 0 for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - get_item_user_response = self.get_user_item_by_index(counter, user, token) + token = self.application.login(user, password).json()["content"] + get_item_user_response = self.application.get_user_item_by_index(counter, user, token) counter = counter + 1 self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertFalse(get_item_user_response.json()["content"]) @@ -40,7 +33,7 @@ def test_get_user_item_by_user(self): def test_get_user_item_by_invalid_token(self): """Test get user item by index with invalid token""" for user in dict.keys(InitUsers.users): - self.login(DefaultUser.user, DefaultUser.password) - get_item_user_response = self.get_user_item_by_index(ITEM_INDEX, user, INVALID_TOKEN) + self.application.login(DefaultUser.user, DefaultUser.password) + get_item_user_response = self.application.get_user_item_by_index(ITEM_INDEX, user, INVALID_TOKEN) self.assertEqual(VALID_STATUS_CODE, get_item_user_response.status_code) self.assertFalse(get_item_user_response.json()["content"]) diff --git a/tests/functional/tests_update_item.py b/tests/functional/tests_update_item.py index 6ca68d8..bb5c62e 100644 --- a/tests/functional/tests_update_item.py +++ b/tests/functional/tests_update_item.py @@ -1,8 +1,9 @@ """Functional tests for update item""" from random import choice, randint -from tests.functional import ApiTestBase + from tests.constants.constants import InitUsers, VALID_STATUS_CODE, ITEM_NAMES, INVALID_TOKEN +from tests.functional import ApiTestBase ITEM_INDEX = randint(0, 1000) @@ -12,29 +13,21 @@ class TestUpdateItem(ApiTestBase): """Class for tests of update item""" - def setUp(self): - super().setUp() - self.reset() - - def tearDown(self): - super().tearDown() - self.reset() - def test_update_empty_item(self): """Test update item when user has no item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - update_item_response = self.update_item(ITEM_INDEX, token, ITEM_NAME) + token = self.application.login(user, password).json()["content"] + update_item_response = self.application.update_item(ITEM_INDEX, token, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertFalse(update_item_response.json()["content"]) def test_update_item(self): """Test update item when user has item""" for user, password in InitUsers.users.items(): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - update_item_response = self.update_item(ITEM_INDEX, token, ITEM_NAME) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + update_item_response = self.application.update_item(ITEM_INDEX, token, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertTrue(update_item_response.json()["content"]) @@ -42,9 +35,9 @@ def test_update_item_invalid_index(self): """Test update item when index not int""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - token = self.login(user, password).json()["content"] - self.add_item(ITEM_INDEX, token, ITEM_NAME) - update_item_response = self.update_item(ITEM_NAME, token, ITEM_NAME) + token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) + update_item_response = self.application.update_item(ITEM_NAME, token, ITEM_NAME) self.assertNotEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertIn("Bad Request", update_item_response.text) @@ -52,7 +45,7 @@ def test_update_item_invalid_token(self): """Test update item with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): - self.login(user, password) - update_item_response = self.update_item(ITEM_INDEX, INVALID_TOKEN, ITEM_NAME) + self.application.login(user, password) + update_item_response = self.application.update_item(ITEM_INDEX, INVALID_TOKEN, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertFalse(update_item_response.json()["content"]) From 52c8d0e7fc671785f244521673f30bd59758bb54 Mon Sep 17 00:00:00 2001 From: pbezrukov <43755852+pbezrukov@users.noreply.github.com> Date: Thu, 1 Nov 2018 23:43:32 +0200 Subject: [PATCH 63/74] Delete application.py --- tests/utils/application.py | 141 ------------------------------------- 1 file changed, 141 deletions(-) delete mode 100644 tests/utils/application.py diff --git a/tests/utils/application.py b/tests/utils/application.py deleted file mode 100644 index 40ef058..0000000 --- a/tests/utils/application.py +++ /dev/null @@ -1,141 +0,0 @@ -import requests -from requests import request - -from tests.constants.constants import Endpoints -from tests.utils.helper import generate_full_url - - -class Wrapper: - - def __init__(self): - self.request_session = requests.session() - self.request_session.close() - - def reset(self): - """Reset API""" - return self.request_session.get(generate_full_url(Endpoints.reset)) - - def login(self, name: str, password: str) -> request: - """Login user with name and password.""" - return self.request_session.post(generate_full_url(Endpoints.login), - params={"name": name, "password": password}) - - def logout(self, name: str, token: str) -> request: - """Logout user with name and user token.""" - return self.request_session.post(generate_full_url(Endpoints.logout), - params={"name": name, "token": token}) - - def login_admins(self, token: str) -> request: - """Logged admins""" - return self.request_session.get(generate_full_url(Endpoints.login_admins), - params={"token": token}) - - def login_users(self, token: str) -> request: - """Logged users""" - return self.request_session.get(generate_full_url(Endpoints.login_users), - params={"token": token}) - - def login_tockens(self, token: str) -> request: - """Alive tokens""" - return self.request_session.get(generate_full_url(Endpoints.login_tockens), - params={"token": token}) - - def admins(self, token: str) -> request: - """All admins""" - return self.request_session.get(generate_full_url(Endpoints.admins), - params={"token": token}) - - def get_user_all_items(self, user, admin_token): - """Get all user items""" - return self.request_session.get(generate_full_url(Endpoints.item_user).format(name=user), - params={"token": admin_token}) - - def get_user_item_by_index(self, index, user, admin_token): - """Get user item by index""" - return self.request_session.get(generate_full_url(Endpoints.item_user_by_index).format(index=index, name=user), - params={"token": admin_token}) - - def add_item(self, index, token, item): - """Add item""" - return self.request_session.post(generate_full_url(Endpoints.item).format(index=index), - params={"token": token, "item": item}) - - def delete_item(self, index, token): - """Delete item""" - return self.request_session.delete(generate_full_url(Endpoints.item).format(index=index), - params={"token": token}) - - def update_item(self, index, token, item): - """Update item""" - return self.request_session.put(generate_full_url(Endpoints.item).format(index=index), - params={"token": token, "item": item}) - - def get_item(self, index, token): - """Get item by index""" - return self.request_session.get(generate_full_url(Endpoints.item).format(index=index), - params={"token": token}) - - def get_item_indexes(self, token): - """Get all item indexes""" - return self.request_session.get(generate_full_url(Endpoints.itemindexes), params={"token": token}) - - def get_all_items(self, token): - """Get all items by user""" - return self.request_session.get(generate_full_url(Endpoints.items), params={"token": token}) - - def change_cool_down_time(self, admin_token, new_value): - """Change cool down time""" - return self.request_session.put(generate_full_url(Endpoints.cooldowntime), - params={"token": admin_token, "time": new_value}) - - def get_cool_down_time(self): - """Get cool down time""" - return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) - - def change_token_life_time(self, admin_token, new_value): - """Change token life time""" - return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), - params={"token": admin_token, "time": new_value}) - - def get_token_life_time(self): - """Get token life time""" - return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) - - def get_all_users(self, admin_token): - """Get all users""" - return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) - - def get_locked_users(self, admin_token): - """Get locked users""" - return self.request_session.get(generate_full_url(Endpoints.locked_users), - params={"token": admin_token}) - - def get_locked_admins(self, admin_token): - """Get locked admins""" - return self.request_session.get(generate_full_url(Endpoints.locked_admins), - params={"token": admin_token}) - - def lock_user(self, admin_token, user_to_lock): - """Lock user by manual command""" - return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), - params={"token": admin_token, 'name': user_to_lock}) - - def unlock_all_users(self, admin_token): - """Unlock all users""" - return self.request_session.put(generate_full_url(Endpoints.locked_reset), - params={"token": admin_token}) - - def unlock_user(self, admin_token, user_to_unlock): - """Unlock user by manual command""" - return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_unlock), - params={"token": admin_token, 'name': user_to_unlock}) - - def create_new_user(self, admin_token, new_name, new_password, admin_rights): - """Create new user""" - return self.request_session.post(generate_full_url(Endpoints.user), - {"token": admin_token, "name": new_name, - "password": new_password, - "rights": admin_rights}) - - def __del__(self): - self.request_session.close() From 5cc3e7140a789e500d212ee4707a9c2420273630 Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Fri, 2 Nov 2018 11:01:37 +0200 Subject: [PATCH 64/74] refactoring code for new architecture replace the api functions from functional/__init__.py to the new file application/application.py --- tests/application/application.py | 165 ++++++++++++++++++++++++ tests/constants/constants.py | 6 +- tests/functional/__init__.py | 164 +---------------------- tests/functional/tests_admins.py | 26 ++-- tests/functional/tests_cooldowntime.py | 60 ++++----- tests/functional/tests_login.py | 82 ++++++------ tests/functional/tests_logout.py | 46 +++---- tests/functional/tests_tokenlifetime.py | 60 ++++----- tests/functional/tests_users.py | 8 +- tests/utils/helper.py | 6 - 10 files changed, 315 insertions(+), 308 deletions(-) create mode 100644 tests/application/application.py diff --git a/tests/application/application.py b/tests/application/application.py new file mode 100644 index 0000000..4408a68 --- /dev/null +++ b/tests/application/application.py @@ -0,0 +1,165 @@ +"""Functions for Spring API testing""" + +import requests +from requests import request + +from tests.constants.constants import Endpoints + + +class ApiWrapper: + """Wrapper for REST API""" + + def __init__(self, app_url): + """Initialize the attributes of a class""" + self.request_session = requests.session() + self.base_url = app_url + + def __del__(self): + """Instance session close""" + self.request_session.close() + + def _generate_full_url(self, path): + """Generate the full url with base url and path""" + return "{}{}".format(self.base_url, path) + + def reset(self): + """Reset API""" + return self.request_session.get(self._generate_full_url(Endpoints.reset)) + + def login(self, name: str, password: str) -> request: + """Login user with name and password.""" + return self.request_session.post(self._generate_full_url(Endpoints.login), + params={"name": name, "password": password}) + + def logout(self, name: str, token: str) -> request: + """Logout user with name and user token.""" + return self.request_session.post(self._generate_full_url(Endpoints.logout), + params={"name": name, "token": token}) + + def login_admins(self, token: str) -> request: + """Logged admins""" + return self.request_session.get(self._generate_full_url(Endpoints.login_admins), + params={"token": token}) + + def login_users(self, token: str) -> request: + """Logged users""" + return self.request_session.get(self._generate_full_url(Endpoints.login_users), + params={"token": token}) + + def login_tockens(self, token: str) -> request: + """Alive tokens""" + return self.request_session.get(self._generate_full_url(Endpoints.login_tockens), + params={"token": token}) + + def admins(self, token: str) -> request: + """All admins""" + return self.request_session.get(self._generate_full_url(Endpoints.admins), + params={"token": token}) + + def get_user_all_items(self, user, admin_token): + """Get all user items""" + return self.request_session.get(self._generate_full_url(Endpoints.item_user).format(name=user), + params={"token": admin_token}) + + def get_user_item_by_index(self, index, user, admin_token): + """Get user item by index""" + return self.request_session.get(self._generate_full_url(Endpoints.item_user_by_index).format(index=index, + name=user), + params={"token": admin_token}) + + def add_item(self, index, token, item): + """Add item""" + return self.request_session.post(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def delete_item(self, index, token): + """Delete item""" + return self.request_session.delete(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def update_item(self, index, token, item): + """Update item""" + return self.request_session.put(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token, "item": item}) + + def get_item(self, index, token): + """Get item by index""" + return self.request_session.get(self._generate_full_url(Endpoints.item).format(index=index), + params={"token": token}) + + def get_item_indexes(self, token): + """Get all item indexes""" + return self.request_session.get(self._generate_full_url(Endpoints.itemindexes), params={"token": token}) + + def get_all_items(self, token): + """Get all items by user""" + return self.request_session.get(self._generate_full_url(Endpoints.items), params={"token": token}) + + def change_cool_down_time(self, admin_token, new_value): + """Change cool down time""" + return self.request_session.put(self._generate_full_url(Endpoints.cooldowntime), + params={"token": admin_token, "time": new_value}) + + def get_cool_down_time(self): + """Get cool down time""" + return self.request_session.get(self._generate_full_url(Endpoints.cooldowntime)) + + def change_token_life_time(self, admin_token, new_value): + """Change token life time""" + return self.request_session.put(self._generate_full_url(Endpoints.tokenlifetime), + params={"token": admin_token, "time": new_value}) + + def get_token_life_time(self): + """Get token life time""" + return self.request_session.get(self._generate_full_url(Endpoints.tokenlifetime)) + + def get_all_users(self, admin_token): + """Get all users""" + return self.request_session.get(self._generate_full_url(Endpoints.users), params={"token": admin_token}) + + def get_locked_users(self, admin_token): + """Get locked users""" + return self.request_session.get(self._generate_full_url(Endpoints.locked_users), + params={"token": admin_token}) + + def get_locked_admins(self, admin_token): + """Get locked admins""" + return self.request_session.get(self._generate_full_url(Endpoints.locked_admins), + params={"token": admin_token}) + + def lock_user(self, admin_token, user_to_lock): + """Lock user by manual command""" + return self.request_session.post((self._generate_full_url(Endpoints.locked_user) + user_to_lock), + params={"token": admin_token, 'name': user_to_lock}) + + def unlock_all_users(self, admin_token): + """Unlock all users""" + return self.request_session.put(self._generate_full_url(Endpoints.locked_reset), + params={"token": admin_token}) + + def unlock_user(self, admin_token, user_to_unlock): + """Unlock user by manual command""" + return self.request_session.put((self._generate_full_url(Endpoints.locked_user) + user_to_unlock), + params={"token": admin_token, 'name': user_to_unlock}) + + def create_new_user(self, admin_token, new_name, new_password, admin_rights): + """Create new user""" + return self.request_session.post(self._generate_full_url(Endpoints.user), + {"token": admin_token, "name": new_name, + "password": new_password, + "rights": admin_rights}) + + def change_pass(self, token, old_password, new_password): + """change pass""" + return self.request_session.put(self._generate_full_url(Endpoints.user), {"token": token, + "oldpassword": old_password, + "newpassword": new_password}) + + def get_user_name(self, token): + """get user name of logged user""" + return self.request_session.get(self._generate_full_url(Endpoints.user), params={"token": token}) + + def delete_user(self, admin_token, name): + """delete user""" + return self.request_session.delete(self._generate_full_url(Endpoints.user), params={"token": admin_token, + "name": name}) diff --git a/tests/constants/constants.py b/tests/constants/constants.py index b65bfc9..75e400e 100644 --- a/tests/constants/constants.py +++ b/tests/constants/constants.py @@ -82,12 +82,12 @@ class BaseUrl: """Url for connecting to API""" base_url = "http://localhost:8080" - + class InvalidUrl: """Invalid url for testing exceptions""" invalid_url = "http://localhost:80801" - - + + class NewUser: """Constants to create new user""" name = "Username" diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index b373f2b..e52b5a0 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -2,11 +2,8 @@ import unittest -import requests -from requests import request - -from tests.constants.constants import Endpoints -from tests.utils.helper import generate_full_url +from tests.application.application import ApiWrapper +from tests.constants.constants import BaseUrl class ApiTestBase(unittest.TestCase): @@ -14,160 +11,11 @@ class ApiTestBase(unittest.TestCase): def setUp(self): """Define open request session that will be executed before each test method.""" - self.request_session = requests.session() - - def change_pass(self, token, old_password, new_password): - """change pass""" - return self.request_session.put(generate_full_url(Endpoints.user), - {"token": token, "oldpassword": old_password, - "newpassword": new_password}) - - def get_user_name(self, token): - """get user name of logged user""" - return self.request_session.get(generate_full_url(Endpoints.user), params={"token": token}) - - def delete_user(self, admin_token, name): - """delete user""" - return self.request_session.delete(generate_full_url(Endpoints.user), params={"token": admin_token, - "name": name}) + self.application = ApiWrapper(BaseUrl.base_url) + self.application.reset() def tearDown(self): """Define close request session and reset API data that will be executed after each test method.""" - self.request_session.get(generate_full_url(Endpoints.reset)) - self.request_session.close() - - def reset(self): - """Reset API""" - return self.request_session.get(generate_full_url(Endpoints.reset)) - - def login(self, name: str, password: str) -> request: - """Login user with name and password.""" - return self.request_session.post(generate_full_url(Endpoints.login), - params={"name": name, "password": password}) - - def logout(self, name: str, token: str) -> request: - """Logout user with name and user token.""" - return self.request_session.post(generate_full_url(Endpoints.logout), - params={"name": name, "token": token}) - - def login_admins(self, token: str) -> request: - """Logged admins""" - return self.request_session.get(generate_full_url(Endpoints.login_admins), - params={"token": token}) - - def login_users(self, token: str) -> request: - """Logged users""" - return self.request_session.get(generate_full_url(Endpoints.login_users), - params={"token": token}) - - def login_tockens(self, token: str) -> request: - """Alive tokens""" - return self.request_session.get(generate_full_url(Endpoints.login_tockens), - params={"token": token}) - - def admins(self, token: str) -> request: - """All admins""" - return self.request_session.get(generate_full_url(Endpoints.admins), - params={"token": token}) - - def get_user_all_items(self, user, admin_token): - """Get all user items""" - return self.request_session.get(generate_full_url(Endpoints.item_user).format(name=user), - params={"token": admin_token}) - - def get_user_item_by_index(self, index, user, admin_token): - """Get user item by index""" - return self.request_session.get(generate_full_url(Endpoints.item_user_by_index).format(index=index, name=user), - params={"token": admin_token}) - - def add_item(self, index, token, item): - """Add item""" - return self.request_session.post(generate_full_url(Endpoints.item).format(index=index), - params={"token": token, "item": item}) - - def delete_item(self, index, token): - """Delete item""" - return self.request_session.delete(generate_full_url(Endpoints.item).format(index=index), - params={"token": token}) - - def update_item(self, index, token, item): - """Update item""" - return self.request_session.put(generate_full_url(Endpoints.item).format(index=index), - params={"token": token, "item": item}) - - def get_item(self, index, token): - """Get item by index""" - return self.request_session.get(generate_full_url(Endpoints.item).format(index=index), - params={"token": token}) - - def get_item_indexes(self, token): - """Get all item indexes""" - return self.request_session.get(generate_full_url(Endpoints.itemindexes), params={"token": token}) - - def get_all_items(self, token): - """Get all items by user""" - return self.request_session.get(generate_full_url(Endpoints.items), params={"token": token}) - - def change_cool_down_time(self, admin_token, new_value): - """Change cool down time""" - return self.request_session.put(generate_full_url(Endpoints.cooldowntime), - params={"token": admin_token, "time": new_value}) - - def get_cool_down_time(self): - """Get cool down time""" - return self.request_session.get(generate_full_url(Endpoints.cooldowntime)) - - def change_token_life_time(self, admin_token, new_value): - """Change token life time""" - return self.request_session.put(generate_full_url(Endpoints.tokenlifetime), - params={"token": admin_token, "time": new_value}) - - def get_token_life_time(self): - """Get token life time""" - return self.request_session.get(generate_full_url(Endpoints.tokenlifetime)) - - def get_all_users(self, admin_token): - """Get all users""" - return self.request_session.get(generate_full_url(Endpoints.users), params={"token": admin_token}) - - def get_locked_users(self, admin_token): - """Get locked users""" - return self.request_session.get(generate_full_url(Endpoints.locked_users), - params={"token": admin_token}) - - def get_locked_admins(self, admin_token): - """Get locked admins""" - return self.request_session.get(generate_full_url(Endpoints.locked_admins), - params={"token": admin_token}) - - def lock_user(self, admin_token, user_to_lock): - """Lock user by manual command""" - return self.request_session.post((generate_full_url(Endpoints.locked_user) + user_to_lock), - params={"token": admin_token, 'name': user_to_lock}) - - def unlock_all_users(self, admin_token): - """Unlock all users""" - return self.request_session.put(generate_full_url(Endpoints.locked_reset), - params={"token": admin_token}) - - def unlock_user(self, admin_token, user_to_unlock): - """Unlock user by manual command""" - return self.request_session.put((generate_full_url(Endpoints.locked_user) + user_to_unlock), - params={"token": admin_token, 'name': user_to_unlock}) - - def create_new_user(self, admin_token, new_name, new_password, admin_rights): - """Create new user""" - return self.request_session.post(generate_full_url(Endpoints.user), - {"token": admin_token, "name": new_name, - "password": new_password, - "rights": admin_rights}) - - -class Ascertains(unittest.TestCase): - """Class for ascertains""" - - def check_status_code_200(self, status_code: int): - """Check if response status code is valid""" - self.assertEqual(status_code, 200, "Error response status code (expected 200)") - + self.application.reset() + del self.application diff --git a/tests/functional/tests_admins.py b/tests/functional/tests_admins.py index 06dcc61..3089a25 100644 --- a/tests/functional/tests_admins.py +++ b/tests/functional/tests_admins.py @@ -1,30 +1,30 @@ """Functional tests for admins""" -from tests.constants.constants import Users, DefaultUser, DefaultToken -from tests.functional import ApiTestBase, Ascertains +from tests.constants.constants import Users, DefaultUser, DefaultToken, VALID_STATUS_CODE +from tests.functional import ApiTestBase -class TestAdmins(ApiTestBase, Ascertains): +class TestAdmins(ApiTestBase): """Class for testing""" def test_admins(self): """Get all admins with admin token. If list not empty test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) - all_admins = self.admins(login.json().get("content")) - self.check_status_code_200(all_admins.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + all_admins = self.application.admins(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) self.assertTrue(all_admins.json().get("content"), "Content is empty") def test_admins_user(self): """Get all admins without admin token. If list empty test pass""" - login = self.login(Users.valid_user, Users.valid_password) - self.check_status_code_200(login.status_code) - all_admins = self.admins(login.json().get("content")) - self.check_status_code_200(all_admins.status_code) + login = self.application.login(Users.valid_user, Users.valid_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + all_admins = self.application.admins(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) self.assertFalse(all_admins.json().get("content"), "Content is not empty") def test_admins_default_token(self): """Get all admins with default token. If list empty test pass""" - all_admins = self.admins(DefaultToken.token) - self.check_status_code_200(all_admins.status_code) + all_admins = self.application.admins(DefaultToken.token) + self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) self.assertFalse(all_admins.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py index 79238fa..d1eff4d 100644 --- a/tests/functional/tests_cooldowntime.py +++ b/tests/functional/tests_cooldowntime.py @@ -17,7 +17,7 @@ def test_get_cool_down_time(self): Get the value of cool down time """ - resp = self.get_cool_down_time() + resp = self.application.get_cool_down_time() self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"] or resp.json()["content"] == 0) @@ -27,14 +27,14 @@ def test_set_cool_down_time_admin_positive(self): Change the cool down time value by admin (positive) """ - new_cdt = get_new_value_different_func(self.get_cool_down_time, 200000, 100000) + new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 200000, 100000) - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_cdt) + resp = self.application.change_cool_down_time(token, new_cdt) - last_resp = self.get_cool_down_time() + last_resp = self.application.get_cool_down_time() cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -46,14 +46,14 @@ def test_set_cool_down_time_admin_negative(self): Change the cool down time value by admin (negative) """ - new_cdt = get_new_value_different_func(self.get_cool_down_time, -200000, -100000) + new_cdt = get_new_value_different_func(self.application.get_cool_down_time, -200000, -100000) - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_cdt) + resp = self.application.change_cool_down_time(token, new_cdt) - last_resp = self.get_cool_down_time() + last_resp = self.application.get_cool_down_time() cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -65,14 +65,14 @@ def test_set_cool_down_time_admin_zero(self): Change the cool down time value by admin (zero) """ - new_cdt = get_new_value_different_func(self.get_cool_down_time, 0, 0) + new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 0, 0) - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_cdt) + resp = self.application.change_cool_down_time(token, new_cdt) - last_resp = self.get_cool_down_time() + last_resp = self.application.get_cool_down_time() cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -87,12 +87,12 @@ def test_set_cool_down_time_admin_none(self): new_cdt = None def_cdt = 1000 - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_cdt) + resp = self.application.change_cool_down_time(token, new_cdt) - last_resp = self.get_cool_down_time() + last_resp = self.application.get_cool_down_time() cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -104,17 +104,17 @@ def test_set_cool_down_time_admin_float(self): Change the cool down time value by admin (float) """ - new_cdt = get_new_value_different_func(self.get_cool_down_time, 200000.555, 100000) + new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 200000.555, 100000) - resp = self.get_cool_down_time() + resp = self.application.get_cool_down_time() curr_cdt = resp.json()["content"] - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_cdt) + resp = self.application.change_cool_down_time(token, new_cdt) - last_resp = self.get_cool_down_time() + last_resp = self.application.get_cool_down_time() cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) @@ -127,15 +127,15 @@ def test_set_cool_down_time_admin_text(self): new_cdt = "f%kdm525!(" - resp = self.get_cool_down_time() + resp = self.application.get_cool_down_time() curr_cdt = resp.json()["content"] - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_cdt) + resp = self.application.change_cool_down_time(token, new_cdt) - last_resp = self.get_cool_down_time() + last_resp = self.application.get_cool_down_time() cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) @@ -146,17 +146,17 @@ def test_set_cool_down_time_user(self): Change the cool down time value by user (without admin rights) """ - new_cdt = get_new_value_different_func(self.get_cool_down_time, 500000, 100000) + new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 500000, 100000) - resp = self.get_cool_down_time() + resp = self.application.get_cool_down_time() curr_cdt = resp.json()["content"] - login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) + login = self.application.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] - resp = self.change_cool_down_time(token, new_cdt) + resp = self.application.change_cool_down_time(token, new_cdt) - last_resp = self.get_cool_down_time() + last_resp = self.application.get_cool_down_time() cdt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py index 26197f3..c6fdf38 100644 --- a/tests/functional/tests_login.py +++ b/tests/functional/tests_login.py @@ -1,101 +1,101 @@ """Functional tests for logging users""" -from tests.constants.constants import DefaultUser, Users, DefaultToken -from tests.functional import ApiTestBase, Ascertains +from tests.constants.constants import DefaultUser, Users, DefaultToken, VALID_STATUS_CODE +from tests.functional import ApiTestBase -class TestLogin(ApiTestBase, Ascertains): +class TestLogin(ApiTestBase): """Class for testing""" def test_login(self): """Login user. If user got token test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertEqual(len(login.json().get("content")), 32, "Invalid token") def test_login_user_not_found(self): """Login fake user name. If user not found test pass.""" - login = self.login(Users.fake_user, Users.fake_password) - self.check_status_code_200(login.status_code) + login = self.application.login(Users.fake_user, Users.fake_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertIn("ERROR, user not found", login.text, "User founded") def test_login_user_locked(self): """Login 4 times with fake password to lock. If user locked test pass.""" for _ in range(4): - login = self.login(Users.valid_user, Users.fake_password) - self.check_status_code_200(login.status_code) + login = self.application.login(Users.valid_user, Users.fake_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertIn("ERROR, user locked", login.text, "User not locked") def test_login_fake_user_locked(self): """Login 4 times with fake user to lock. If user not found test pass.""" for _ in range(4): - login = self.login(Users.fake_user, Users.fake_password) - self.check_status_code_200(login.status_code) + login = self.application.login(Users.fake_user, Users.fake_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertIn("ERROR, user not found", login.text, "User locked") def test_login_admins(self): """Get logged admins with admin token. If user had admin rights and got the list of logged admins test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) - logged_admins = self.login_admins(login.json().get("content")) - self.check_status_code_200(logged_admins.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logged_admins = self.application.login_admins(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_admins_user(self): """Get logged admins without admin token. If empty response test pass.""" - login = self.login(Users.valid_user, Users.valid_password) - self.check_status_code_200(login.status_code) - logged_admins = self.login_admins(login.json().get("content")) - self.check_status_code_200(logged_admins.status_code) + login = self.application.login(Users.valid_user, Users.valid_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logged_admins = self.application.login_admins(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) self.assertFalse(logged_admins.json().get("content"), "Content is not empty") def test_login_admins_default_token(self): """Get logged admins with default token. If empty response test pass.""" - logged_admins = self.login_admins(DefaultToken.token) - self.check_status_code_200(logged_admins.status_code) + logged_admins = self.application.login_admins(DefaultToken.token) + self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) self.assertFalse(logged_admins.json().get("content"), "Content is not empty") def test_login_users_admin(self): """Get logged users with admin token. If got the list of logged users test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) - logged_admins = self.login_users(login.json().get("content")) - self.check_status_code_200(logged_admins.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logged_admins = self.application.login_users(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_users(self): """Get logged users without admin token. If list of users empty test pass.""" - login = self.login(Users.valid_user, Users.valid_password) - self.check_status_code_200(login.status_code) - logged_users = self.login_users(login.json().get("content")) - self.check_status_code_200(logged_users.status_code) + login = self.application.login(Users.valid_user, Users.valid_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logged_users = self.application.login_users(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logged_users.status_code) self.assertFalse(logged_users.json().get("content"), "Content is not empty") def test_login_users_default_token(self): """Get logged users without admin token. If list of users empty test pass.""" - logged_users = self.login_users(DefaultToken.token) - self.check_status_code_200(logged_users.status_code) + logged_users = self.application.login_users(DefaultToken.token) + self.assertEqual(VALID_STATUS_CODE, logged_users.status_code) self.assertFalse(logged_users.json().get("content"), "Content is not empty") def test_login_tockens_admin(self): """Get alive tockens with admin token. If got list of tokens test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) - alive_tokens = self.login_tockens(login.json().get("content")) - self.check_status_code_200(alive_tokens.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + alive_tokens = self.application.login_tockens(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) self.assertTrue(alive_tokens.json().get("content"), "Content is empty") def test_login_tockens_users(self): """Get alive tockens without admin token. If list of tokens empty test pass""" - login = self.login(Users.valid_user, Users.valid_password) - self.check_status_code_200(login.status_code) - alive_tokens = self.login_tockens(login.json().get("content")) - self.check_status_code_200(alive_tokens.status_code) + login = self.application.login(Users.valid_user, Users.valid_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + alive_tokens = self.application.login_tockens(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") def test_login_tockens_users_default_token(self): """Get alive tockens with default token. If list of tokens empty test pass""" - alive_tokens = self.login_tockens(DefaultToken.token) - self.check_status_code_200(alive_tokens.status_code) + alive_tokens = self.application.login_tockens(DefaultToken.token) + self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_logout.py b/tests/functional/tests_logout.py index 08cab41..6dcbd34 100644 --- a/tests/functional/tests_logout.py +++ b/tests/functional/tests_logout.py @@ -1,51 +1,51 @@ """Functional tests for logout users""" -from tests.constants.constants import DefaultUser, Users, DefaultToken -from tests.functional import ApiTestBase, Ascertains +from tests.constants.constants import DefaultUser, Users, DefaultToken, VALID_STATUS_CODE +from tests.functional import ApiTestBase -class TestLogout(ApiTestBase, Ascertains): +class TestLogout(ApiTestBase): """Class for testing""" def test_logout(self): """Logout user. If request true and user logout test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) - logout = self.logout(DefaultUser.user, login.json().get("content")) - self.check_status_code_200(logout.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logout = self.application.logout(DefaultUser.user, login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logout.status_code) self.assertTrue(logout.json().get("content"), "User not logout") def test_logout_another_user(self): """Login user1, logout another user2 with user1 token. If request false and user2 didn't logout test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) - logout = self.logout(Users.valid_user, login.json().get("content")) - self.check_status_code_200(logout.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logout = self.application.logout(Users.valid_user, login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logout.status_code) self.assertFalse(logout.json().get("content"), "User logout") def test_logout_another_token(self): """Login user, logout with another token. If request false and user didn't logout test pass.""" - login = self.login(DefaultUser.user, DefaultUser.password) - self.check_status_code_200(login.status_code) - logout = self.logout(DefaultUser.user, DefaultToken.token) - self.check_status_code_200(logout.status_code) + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logout = self.application.logout(DefaultUser.user, DefaultToken.token) + self.assertEqual(VALID_STATUS_CODE, logout.status_code) self.assertFalse(logout.json().get("content"), "User logout") def test_logout_fake_users(self): """Logout fake user. If request false and user didn't logout test pass.""" - login = self.login(Users.fake_user, Users.fake_password) - self.check_status_code_200(login.status_code) - logout = self.logout(Users.fake_user, login.json().get("content")) - self.check_status_code_200(logout.status_code) + login = self.application.login(Users.fake_user, Users.fake_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logout = self.application.logout(Users.fake_user, login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logout.status_code) self.assertFalse(logout.json().get("content"), "User logout") def test_logout_locked_users(self): """Logout locked user. If request false user didn't logout and test pass.""" for _ in range(4): - login = self.login(Users.valid_user, Users.fake_password) - self.check_status_code_200(login.status_code) - logout = self.logout(Users.fake_user, login.json().get("content")) - self.check_status_code_200(logout.status_code) + login = self.application.login(Users.valid_user, Users.fake_password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logout = self.application.logout(Users.fake_user, login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logout.status_code) self.assertFalse(logout.json().get("content"), "User logout") diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py index 3ff9783..6855cad 100644 --- a/tests/functional/tests_tokenlifetime.py +++ b/tests/functional/tests_tokenlifetime.py @@ -17,7 +17,7 @@ def test_get_token_life_time(self): Get the value of token life time """ - resp = self.get_token_life_time() + resp = self.application.get_token_life_time() self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"] or resp.json()["content"] == 0) @@ -27,14 +27,14 @@ def test_set_token_life_time_admin_positive(self): Change the token life time value by admin (positive) """ - new_tlt = get_new_value_different_func(self.get_token_life_time, 200000, 100000) + new_tlt = get_new_value_different_func(self.application.get_token_life_time, 200000, 100000) - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_tlt) + resp = self.application.change_token_life_time(token, new_tlt) - last_resp = self.get_token_life_time() + last_resp = self.application.get_token_life_time() tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -46,14 +46,14 @@ def test_set_token_life_time_admin_negative(self): Change the token life time value by admin (negative) """ - new_tlt = get_new_value_different_func(self.get_token_life_time, -200000, -100000) + new_tlt = get_new_value_different_func(self.application.get_token_life_time, -200000, -100000) - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_tlt) + resp = self.application.change_token_life_time(token, new_tlt) - last_resp = self.get_token_life_time() + last_resp = self.application.get_token_life_time() tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -65,14 +65,14 @@ def test_set_token_life_time_admin_zero(self): Change the token life time value by admin (zero) """ - new_tlt = get_new_value_different_func(self.get_token_life_time, 0, 0) + new_tlt = get_new_value_different_func(self.application.get_token_life_time, 0, 0) - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_tlt) + resp = self.application.change_token_life_time(token, new_tlt) - last_resp = self.get_token_life_time() + last_resp = self.application.get_token_life_time() tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -87,12 +87,12 @@ def test_set_token_life_time_admin_none(self): new_tlt = None def_tlt = 1000 - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_tlt) + resp = self.application.change_token_life_time(token, new_tlt) - last_resp = self.get_token_life_time() + last_resp = self.application.get_token_life_time() tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) @@ -104,17 +104,17 @@ def test_set_token_life_time_admin_float(self): Change the token life time value by admin (float) """ - new_tlt = get_new_value_different_func(self.get_token_life_time, 200000.555, 100000) + new_tlt = get_new_value_different_func(self.application.get_token_life_time, 200000.555, 100000) - resp = self.get_token_life_time() + resp = self.application.get_token_life_time() curr_tlt = resp.json()["content"] - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_tlt) + resp = self.application.change_token_life_time(token, new_tlt) - last_resp = self.get_token_life_time() + last_resp = self.application.get_token_life_time() tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) @@ -127,15 +127,15 @@ def test_set_token_life_time_admin_text(self): new_tlt = "f%kdm525!(" - resp = self.get_token_life_time() + resp = self.application.get_token_life_time() curr_tlt = resp.json()["content"] - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - resp = self.change_token_life_time(token, new_tlt) + resp = self.application.change_token_life_time(token, new_tlt) - last_resp = self.get_token_life_time() + last_resp = self.application.get_token_life_time() tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 400) @@ -146,17 +146,17 @@ def test_set_token_life_time_user(self): Change the token life time value by user (without admin rights) """ - new_tlt = get_new_value_different_func(self.get_token_life_time, 500000, 100000) + new_tlt = get_new_value_different_func(self.application.get_token_life_time, 500000, 100000) - resp = self.get_token_life_time() + resp = self.application.get_token_life_time() curr_tlt = resp.json()["content"] - login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) + login = self.application.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] - resp = self.change_token_life_time(token, new_tlt) + resp = self.application.change_token_life_time(token, new_tlt) - last_resp = self.get_token_life_time() + last_resp = self.application.get_token_life_time() tlt_after = last_resp.json()["content"] self.assertEqual(resp.status_code, 200) diff --git a/tests/functional/tests_users.py b/tests/functional/tests_users.py index af37516..6eb8a35 100644 --- a/tests/functional/tests_users.py +++ b/tests/functional/tests_users.py @@ -16,10 +16,10 @@ def test_get_all_users_admin(self): Get the list of all users by admin """ - login = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + login = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) token = login.json()["content"] - req = self.get_all_users(token) + req = self.application.get_all_users(token) self.assertEqual(req.status_code, 200) self.assertTrue(req.json()["content"]) @@ -29,10 +29,10 @@ def test_get_all_users_user(self): Get the list of all users by user (without admin rights) """ - login = self.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) + login = self.application.login(DefaultUser.user_akimatc, DefaultUser.password_akimatc) token = login.json()["content"] - req = self.get_all_users(token) + req = self.application.get_all_users(token) self.assertEqual(req.status_code, 200) self.assertFalse(req.json()["content"]) diff --git a/tests/utils/helper.py b/tests/utils/helper.py index 6ab2dcc..5fe1578 100644 --- a/tests/utils/helper.py +++ b/tests/utils/helper.py @@ -1,11 +1,5 @@ """Help functions for testing""" -from tests.constants.constants import BaseUrl - - -def generate_full_url(path): - """Generate the full url with base url and path""" - return "{}{}".format(BaseUrl.base_url, path) def get_new_value_different_func(func, new_value, step): """ From 5aeb8ff8fb02c1b401adb4b38e1dfb88414bd4e6 Mon Sep 17 00:00:00 2001 From: pbezrukov Date: Fri, 2 Nov 2018 12:41:52 +0200 Subject: [PATCH 65/74] reactoring --- tests/application/application.py | 5 ++ tests/functional/__init__.py | 12 +++-- tests/functional/tests_locked.py | 78 ++++++++++++++------------------ tests/functional/tests_login.py | 4 +- 4 files changed, 49 insertions(+), 50 deletions(-) diff --git a/tests/application/application.py b/tests/application/application.py index 3d1aa58..c0710ae 100644 --- a/tests/application/application.py +++ b/tests/application/application.py @@ -1,3 +1,5 @@ +"""One class for API""" + import requests from requests import request @@ -5,12 +7,15 @@ class ApiWrapper: + """Class for all methods""" def __init__(self, app_url): + """Init all methods and open request session """ self.request_session = requests.session() self.base_url = app_url def __del__(self): + """Close request session""" self.request_session.close() def _generate_full_url(self, path): diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py index 820062d..6d80e40 100644 --- a/tests/functional/__init__.py +++ b/tests/functional/__init__.py @@ -9,16 +9,18 @@ class ApiTestBase(unittest.TestCase): """Main class for testing""" + @classmethod + def setUpClass(cls): + """Define open request session that will be executed before each class test method.""" + cls.application = ApiWrapper(BaseUrl.base_url) + def setUp(self): - """Define open request session that will be executed before each test method.""" - self.application = ApiWrapper(BaseUrl.base_url) + """Define reset API data before each test method.""" self.application.reset() def tearDown(self): - """Define close request session and reset API data - that will be executed after each test method.""" + """Reset API data that will be executed after each test method.""" self.application.reset() - del self.application class Assertions(unittest.TestCase): diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 648ea27..91ea6ea 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -11,7 +11,7 @@ class TestLocked(ApiTestBase): def setUp(self): """Return admin token""" super().setUp() - response = self.login(DefaultUser.user_admin, DefaultUser.password_admin) + response = self.application.login(DefaultUser.user_admin, DefaultUser.password_admin) self.admin_token = response.json()['content'] self.kwargs = {'token': self.admin_token} @@ -21,8 +21,8 @@ def test_locked(self): user = choice(list(users.keys())) # returning random user wrong_password = Users.fake_password for _ in range(3): - self.login(user, wrong_password) - locked_users_request = self.get_locked_users(self.admin_token) + self.application.login(user, wrong_password) + locked_users_request = self.application.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] self.assertIn(user, locked_users) @@ -32,8 +32,8 @@ def test_not_locked(self): user = choice(list(users.keys())) # returning random user wrong_passwords = ['', 'password'] for wrong_password in wrong_passwords: - self.login(user, wrong_password) - locked_users_request = self.get_locked_users(self.admin_token) + self.application.login(user, wrong_password) + locked_users_request = self.application.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] self.assertNotIn(user, locked_users) @@ -41,8 +41,8 @@ def test_manual_lock(self): """Test functionality of locking users by manual command""" users = InitUsers.users.copy() user_to_lock = choice(list(users.keys())) # returning random user - self.lock_user(self.admin_token, user_to_lock) - locked_users_request = self.get_locked_users(self.admin_token) + self.application.lock_user(self.admin_token, user_to_lock) + locked_users_request = self.application.get_locked_users(self.admin_token) self.assertIn(user_to_lock, locked_users_request.text) def test_manual_unlock(self): @@ -51,9 +51,9 @@ def test_manual_unlock(self): user_to_lock = choice(list(users.keys())) # returning random user wrong_password = Users.fake_password for _ in range(3): - self.login(user_to_lock, wrong_password) - self.unlock_user(self.admin_token, user_to_lock) - locked_users_request = self.get_locked_users(self.admin_token) + self.application.login(user_to_lock, wrong_password) + self.application.unlock_user(self.admin_token, user_to_lock) + locked_users_request = self.application.get_locked_users(self.admin_token) locked_users = locked_users_request.text self.assertNotIn(user_to_lock, locked_users) @@ -62,41 +62,33 @@ def test_reset_locked_admin_token(self): users = InitUsers.users.copy() wrong_password = Users.fake_password for user in users.keys(): - self.login(user, wrong_password) - self.unlock_all_users(self.admin_token) - locked_users_request = self.get_locked_users(self.admin_token) + self.application.login(user, wrong_password) + self.application.unlock_all_users(self.admin_token) + locked_users_request = self.application.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') - def test_reset_locked_user_token(self): - """Test functionality of unlocking all users with user token""" - pass - - def test_reset_locked_empty_token(self): - """Test functionality of unlocking all users with empty token""" - pass - def test_locked_admins(self): """Test functionality of locking admins""" new_user_name = NewUser.name new_user_pass = NewUser.password - self.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') + self.application.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') wrong_password = Users.fake_password for _ in range(3): - self.login(new_user_name, wrong_password) - locked_admins = self.get_locked_admins(self.admin_token) + self.application.login(new_user_name, wrong_password) + locked_admins = self.application.get_locked_admins(self.admin_token) self.assertIn(new_user_name, locked_admins.text) def test_not_locked_admin(self): """Admin should not be locked""" new_user_name = NewUser.name new_user_pass = NewUser.password - self.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') + self.application.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') passwords = ['', 'password', new_user_pass] for password in passwords: - self.login(new_user_name, password) - locked_admins = self.get_locked_admins(self.admin_token) - logined_admins = self.login_admins(self.admin_token) + self.application.login(new_user_name, password) + locked_admins = self.application.get_locked_admins(self.admin_token) + logined_admins = self.application.login_admins(self.admin_token) self.assertNotIn(new_user_name, locked_admins.text) self.assertIn(new_user_name, logined_admins.text) @@ -105,10 +97,10 @@ def test_manual_lock_user_token(self): users = InitUsers.users.copy() user, password = users.popitem() # user for login user_to_lock = choice(list(users.keys())) # returning random user for lock - login_for_token = self.login(user, password) + login_for_token = self.application.login(user, password) token = login_for_token.json()['content'] - self.lock_user(token, user_to_lock) - locked_users_request = self.get_locked_users(self.admin_token) + self.application.lock_user(token, user_to_lock) + locked_users_request = self.application.get_locked_users(self.admin_token) self.assertNotIn(user_to_lock, locked_users_request.text) def test_locking_unexisting_user(self): @@ -116,8 +108,8 @@ def test_locking_unexisting_user(self): fake_user = Users.fake_user fake_password = Users.fake_password for _ in range(3): - self.login(fake_user, fake_password) - locked_users_request = self.get_locked_users(self.admin_token) + self.application.login(fake_user, fake_password) + locked_users_request = self.application.get_locked_users(self.admin_token) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') @@ -126,19 +118,19 @@ def test_get_locked_admins_user_token(self): users = InitUsers.users.copy() user, password = choice(list(users.items())) for _ in range(3): - self.login(DefaultUser.user_admin, Users.fake_password) # locking admin - login_for_token = self.login(user, password) + self.application.login(DefaultUser.user_admin, Users.fake_password) # locking admin + login_for_token = self.application.login(user, password) user_token = login_for_token.json()['content'] - locked_admins_request = self.get_locked_admins(user_token) + locked_admins_request = self.application.get_locked_admins(user_token) locked_admin = locked_admins_request.json()['content'] self.assertEqual(locked_admin, '') def test_get_locked_admins_empty_token(self): """Discovering locked admins with empty token""" for _ in range(3): - self.login(DefaultUser.user_admin, Users.fake_password) + self.application.login(DefaultUser.user_admin, Users.fake_password) token = '' - locked_admins_request = self.get_locked_admins(token) + locked_admins_request = self.application.get_locked_admins(token) locked_admin = locked_admins_request.json()['content'] self.assertEqual(locked_admin, '') @@ -147,11 +139,11 @@ def test_get_locked_users_user_token(self): users = InitUsers.users.copy() users.pop('admin', None) user, pasword = users.popitem() - login_for_user_token = self.login(user, pasword) + login_for_user_token = self.application.login(user, pasword) user_token = login_for_user_token.json()['content'] user_to_lock = list(users.keys())[0] - self.login(user_to_lock, Users.fake_password) - locked_users_request = self.get_locked_users(user_token) + self.application.login(user_to_lock, Users.fake_password) + locked_users_request = self.application.get_locked_users(user_token) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') @@ -161,8 +153,8 @@ def test_get_locked_users_empty_token(self): users.pop('admin', None) user_to_lock = list(users.keys())[0] for _ in range(3): - self.login(user_to_lock, Users.fake_password) + self.application.login(user_to_lock, Users.fake_password) token = '' - locked_users_request = self.get_locked_users(token) + locked_users_request = self.application.get_locked_users(token) locked_users = locked_users_request.json()['content'] self.assertEqual(locked_users, '') diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py index 1617ed7..4215fa6 100644 --- a/tests/functional/tests_login.py +++ b/tests/functional/tests_login.py @@ -23,8 +23,8 @@ def test_login_user_locked(self): """Login 4 times with fake password to lock. If user locked test pass.""" for _ in range(4): login = self.application.login(Users.valid_user, Users.fake_password) - self.check_status_code_200(login.status_code) - self.assertIn("ERROR, user locked", login.text, "User not locked") + self.check_status_code_200(login.status_code) + self.assertIn("ERROR, user locked", login.text, "User not locked") def test_login_fake_user_locked(self): """Login 4 times with fake user to lock. If user not found test pass.""" From 554d6e0332c8b0ed786599b5bc6972e959839004 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Fri, 2 Nov 2018 13:25:22 +0200 Subject: [PATCH 66/74] Application changes in tests --- tests/functional/tests_get_user_name.py | 6 ++-- tests/functional/tests_user_change_pass.py | 10 +++---- tests/functional/tests_user_create_new.py | 28 +++++++++--------- tests/functional/tests_user_remove.py | 34 +++++++++++----------- 4 files changed, 39 insertions(+), 39 deletions(-) diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py index b9d5cf1..c116ad3 100644 --- a/tests/functional/tests_get_user_name.py +++ b/tests/functional/tests_get_user_name.py @@ -10,7 +10,7 @@ def setUp(self): """Get user token""" super().setUp() - response = self.login(UserToTest.login, UserToTest.password) + response = self.application.login(UserToTest.login, UserToTest.password) self.token = response.json()['content'] self.assertEqual(200, response.status_code, "login error") @@ -18,7 +18,7 @@ def test_get_user_name(self): """Getting logged in name with existing user""" # get user name from response - response = self.get_user_name(self.token) + response = self.application.get_user_name(self.token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) self.assertEqual(UserToTest.login, returned_user_name) @@ -29,7 +29,7 @@ def test_invalid_token(self): wrong_token = self.token + "WK" # get user name from response - response = self.get_user_name(wrong_token) + response = self.application.get_user_name(wrong_token) returned_user_name = response.json()['content'] self.assertEqual(200, response.status_code) self.assertEqual("", returned_user_name) diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py index 8533d96..766585e 100644 --- a/tests/functional/tests_user_change_pass.py +++ b/tests/functional/tests_user_change_pass.py @@ -14,7 +14,7 @@ def setUp(self): """Get user token""" super().setUp() - response = self.login(UserToTest.login, UserToTest.password) + response = self.application.login(UserToTest.login, UserToTest.password) self.token = response.json()['content'] self.assertEqual(200, response.status_code, "login error") @@ -23,12 +23,12 @@ def test_change_pass_valid_data(self): # change pass new_pass = UserToTest.password + "wk" - change_pass = self.change_pass(self.token, UserToTest.password, new_pass) + change_pass = self.application.change_pass(self.token, UserToTest.password, new_pass) self.assertEqual(200, change_pass.status_code) self.assertTrue(change_pass.text) # login with changed pass - login_with_new_pass = self.login(UserToTest.login, new_pass) + login_with_new_pass = self.application.login(UserToTest.login, new_pass) len_token = len(login_with_new_pass.json()['content']) self.assertEqual(200, login_with_new_pass.status_code) self.assertEqual(32, len_token) @@ -38,12 +38,12 @@ def test_change_pass(self, value): """Change pass with invalid values""" # change pass - change_pass = self.change_pass(self.token, UserToTest.password, value) + change_pass = self.application.change_pass(self.token, UserToTest.password, value) self.assertEqual(200, change_pass.status_code) self.assertTrue(change_pass.text) # login with changed pass - login_with_new_pass = self.login(UserToTest.login, value) + login_with_new_pass = self.application.login(UserToTest.login, value) len_token = len(login_with_new_pass.json()['content']) self.assertEqual(200, login_with_new_pass.status_code) self.assertNotEqual(32, len_token, "Pass changed to wrong: " + value) diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index e0f19b1..b59cad0 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -14,19 +14,19 @@ def setUp(self): """login admin and get admin token""" super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) + response = self.application.login(DefaultUser.user, DefaultUser.password) self.admin_token = response.json()['content'] def test_create_new_user(self): """create new user with valid data""" - create_new_user = self.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.isUser) + create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) # try to login with new user - login = self.login(NewUser.name, NewUser.password) + login = self.application.login(NewUser.name, NewUser.password) len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertEqual(32, len_of_new_user_token) @@ -34,12 +34,12 @@ def test_create_new_user(self): def test_create_new_with_exist_name(self): """create new user with already exist name""" - create_new_user = self.create_new_user(self.admin_token, DefaultUser.user, NewUser.password, NewUser.isUser) + create_new_user = self.application.create_new_user(self.admin_token, DefaultUser.user, NewUser.password, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) # try to login with new user - login = self.login(DefaultUser.user, NewUser.password) + login = self.application.login(DefaultUser.user, NewUser.password) len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertNotEqual(32, len_of_new_user_token, "User was created with a name what already exist") @@ -48,29 +48,29 @@ def test_with_non_admin_token(self): """create new user with usage of non admin token""" # login with existed user - login = self.login(UserToTest.login, UserToTest.password) + login = self.application.login(UserToTest.login, UserToTest.password) user_token = login.json()['content'] # create new user with user token - create_new_user = self.create_new_user(user_token, NewUser.name, NewUser.password, NewUser.isUser) + create_new_user = self.application.create_new_user(user_token, NewUser.name, NewUser.password, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) # try to login with new user - login_new_user = self.login(NewUser.name, NewUser.password) + login_new_user = self.application.login(NewUser.name, NewUser.password) self.assertEqual(200, login_new_user.status_code) self.assertIn("ERROR", login_new_user.text, "User was created with user token") def test_give_invalid_admin_rights(self): """create new user with invalid admin rights""" - create_new_user = self.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.wrong_rights) + create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.wrong_rights) self.assertIn("Bad Request", create_new_user.text) self.assertEqual(400, create_new_user.status_code) self.assertNotEqual(200, create_new_user.status_code) # try to login with new user - login = self.login(NewUser.name, NewUser.password) + login = self.application.login(NewUser.name, NewUser.password) text_of_login_message = str(login.content) self.assertIn("ERROR", text_of_login_message, "User was created with invalid admin rights") @@ -79,12 +79,12 @@ def test_wrong_new_login(self, value): """create new user with spaces on login""" # login_with_space = InvalidValues.values[0] - create_new_user = self.create_new_user(self.admin_token, value, NewUser.password, NewUser.isUser) + create_new_user = self.application.create_new_user(self.admin_token, value, NewUser.password, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) # try to login with new user - login = self.login(value, NewUser.password) + login = self.application.login(value, NewUser.password) len_of_new_user_token = len(login.json()['content']) self.assertNotEqual(32, len_of_new_user_token, "Wrong login name: " + value) @@ -92,12 +92,12 @@ def test_wrong_new_login(self, value): def test_wrong_new_pass(self, value): """create new user with only spaces on login""" - create_new_user = self.create_new_user(self.admin_token, NewUser.name, value, NewUser.isUser) + create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, value, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) # try to login with new user - login = self.login(NewUser.name, value) + login = self.application.login(NewUser.name, value) len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertNotEqual(32, len_of_new_user_token, "User was created with wrong pass: " + value) diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py index 2507ec1..cd1bdcf 100644 --- a/tests/functional/tests_user_remove.py +++ b/tests/functional/tests_user_remove.py @@ -13,18 +13,18 @@ def setUp(self): """Get admin token""" super().setUp() - response = self.login(DefaultUser.user, DefaultUser.password) + response = self.application.login(DefaultUser.user, DefaultUser.password) self.admin_token = response.json()['content'] def test_remove_user(self): """delete user with valid data""" - removed_user = self.delete_user(self.admin_token, UserToTest.login) + removed_user = self.application.delete_user(self.admin_token, UserToTest.login) self.assertTrue(removed_user.text) self.assertEqual(200, removed_user.status_code) # search user in user list - get_user_list = self.get_all_users(self.admin_token) + get_user_list = self.application.get_all_users(self.admin_token) self.assertEqual(200, get_user_list.status_code) self.assertNotIn(UserToTest.login, get_user_list.text, "User was not deleted") @@ -32,7 +32,7 @@ def test_delete_without_name(self): """Try to delete user without name, only with token""" name_empty = InvalidValues.values[2] - removed_user = self.delete_user(self.admin_token, name_empty) + removed_user = self.application.delete_user(self.admin_token, name_empty) self.assertEqual(200, removed_user.status_code) self.assertIn("false", removed_user.text, "Error. User was deleted without name") @@ -40,68 +40,68 @@ def test_delete_without_token(self): """Try to delete user without token, only with name""" token_empty = InvalidValues.values[2] - removed_user = self.delete_user(token_empty, UserToTest.login) + removed_user = self.application.delete_user(token_empty, UserToTest.login) self.assertEqual(200, removed_user.status_code) self.assertIn("false", removed_user.text, "Error, we got deletion without token") def test_admin_delete_himself(self): """Delete admin""" - removed_user = self.delete_user(self.admin_token, DefaultUser.user) + removed_user = self.application.delete_user(self.admin_token, DefaultUser.user) get_answer = str(removed_user.json()['content']) self.assertIn('True', get_answer) self.assertEqual(200, removed_user.status_code) # search user in user list - get_user_list = self.get_all_users(self.admin_token) + get_user_list = self.application.get_all_users(self.admin_token) self.assertIn(DefaultUser.user, get_user_list.text, "Error, admin has deleted himself") def test_user_delete_himself(self): """User delete himself with user token""" - login = self.login(UserToTest.login, UserToTest.password) + login = self.application.login(UserToTest.login, UserToTest.password) token = login.json()['content'] let_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertEqual(32, let_token) # Use User token to delete himself - removed_user = self.delete_user(token, UserToTest.login) + removed_user = self.application.delete_user(token, UserToTest.login) get_answer = str(removed_user.json()['content']) self.assertEqual(200, removed_user.status_code) self.assertIn('False', get_answer, 'ERROR. User was deleted with user token!') self.assertNotEqual(32, len(get_answer)) # search deleted user in user list - get_user_list = self.get_all_users(self.admin_token) + get_user_list = self.application.get_all_users(self.admin_token) self.assertIn(UserToTest.login, get_user_list.text, "Error, user delete himself with user token") def test_user_token_delete_admin(self): """Login with user and use user token to delete admin""" # login with user and get user token - login = self.login(UserToTest.login, UserToTest.password) + login = self.application.login(UserToTest.login, UserToTest.password) token = login.json()['content'] let_token = len(login.json()['content']) self.assertEqual(200, login.status_code) self.assertEqual(32, let_token) # del admin with user token - removed_user = self.delete_user(token, DefaultUser.user) + removed_user = self.application.delete_user(token, DefaultUser.user) get_answer = str(removed_user.json()['content']) self.assertEqual(200, removed_user.status_code) self.assertIn('False', get_answer, 'ERROR. Admin was deleted with user token!') self.assertNotEqual(32, len(get_answer)) # search admin in user list - get_user_list = self.get_all_users(self.admin_token) + get_user_list = self.application.get_all_users(self.admin_token) self.assertIn(DefaultUser.user, get_user_list.text, "Error, user delete admin with user token") def test_admin_token_not_right(self): """Use wrong token""" invalid_token = DefaultToken.token - removed_user = self.delete_user(invalid_token, UserToTest.login) + removed_user = self.application.delete_user(invalid_token, UserToTest.login) get_answer = str(removed_user.json()['content']) len_token = len(get_answer) self.assertEqual(200, removed_user.status_code) @@ -109,15 +109,15 @@ def test_admin_token_not_right(self): self.assertNotEqual(32, len_token) # search deleted user in user list - get_user_list = self.get_all_users(self.admin_token) + get_user_list = self.application.get_all_users(self.admin_token) self.assertIn(UserToTest.login, get_user_list.text, "Error, user was deleted with wrong token") def test_user_not_exist_deletion(self): """Delete not exist user""" - removed_user = self.delete_user(self.admin_token, "testuser") + removed_user = self.application.delete_user(self.admin_token, "testuser") self.assertEqual(200, removed_user.status_code) # search test user in user list - get_user_list = self.get_all_users(self.admin_token) + get_user_list = self.application.get_all_users(self.admin_token) self.assertNotIn("testuser", get_user_list.text, "Error, not exist user was deleted") From ae4cfdd162025a4a65703521e8c68fce6bcdea98 Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Mon, 5 Nov 2018 12:52:36 +0200 Subject: [PATCH 67/74] docstings reworked --- tests/functional/tests_locked.py | 66 +++++++++++++++++++++++++------- 1 file changed, 53 insertions(+), 13 deletions(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 91ea6ea..0032707 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -1,6 +1,7 @@ """Testing functionality of locking users""" from random import choice + from tests.constants.constants import DefaultUser, InitUsers, NewUser, Users from tests.functional import ApiTestBase @@ -16,7 +17,10 @@ def setUp(self): self.kwargs = {'token': self.admin_token} def test_locked(self): - """Test functionality of locking user""" + """Test functionality of locking user after 3 wrong password attempts + (user should be locked) + """ + users = InitUsers.users.copy() user = choice(list(users.keys())) # returning random user wrong_password = Users.fake_password @@ -27,7 +31,10 @@ def test_locked(self): self.assertIn(user, locked_users) def test_not_locked(self): - """User should not be locked""" + """User should not be locked after 2 wrong password attempts + (user should not be locked) + """ + users = InitUsers.users.copy() user = choice(list(users.keys())) # returning random user wrong_passwords = ['', 'password'] @@ -38,7 +45,10 @@ def test_not_locked(self): self.assertNotIn(user, locked_users) def test_manual_lock(self): - """Test functionality of locking users by manual command""" + """Test functionality of locking users by manual command with admin token + (user should be locked) + """ + users = InitUsers.users.copy() user_to_lock = choice(list(users.keys())) # returning random user self.application.lock_user(self.admin_token, user_to_lock) @@ -46,7 +56,10 @@ def test_manual_lock(self): self.assertIn(user_to_lock, locked_users_request.text) def test_manual_unlock(self): - """Test functionality of unlocking users by manual command""" + """Test functionality of unlocking user by manual command with admin token + (user should be unlocked) + """ + users = InitUsers.users.copy() user_to_lock = choice(list(users.keys())) # returning random user wrong_password = Users.fake_password @@ -58,7 +71,10 @@ def test_manual_unlock(self): self.assertNotIn(user_to_lock, locked_users) def test_reset_locked_admin_token(self): - """Test functionality of unlocking all users with admin token""" + """Test functionality of unlocking all users with admin token + (all users should be unlocked) + """ + users = InitUsers.users.copy() wrong_password = Users.fake_password for user in users.keys(): @@ -69,7 +85,10 @@ def test_reset_locked_admin_token(self): self.assertEqual(locked_users, '') def test_locked_admins(self): - """Test functionality of locking admins""" + """Test functionality of locking admins after 3 wrong password attempts + (admin should be locked) + """ + new_user_name = NewUser.name new_user_pass = NewUser.password self.application.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') @@ -80,7 +99,10 @@ def test_locked_admins(self): self.assertIn(new_user_name, locked_admins.text) def test_not_locked_admin(self): - """Admin should not be locked""" + """Admin should not be locked after 2 wrong password attempts + (admin should not be locked) + """ + new_user_name = NewUser.name new_user_pass = NewUser.password self.application.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') @@ -93,7 +115,10 @@ def test_not_locked_admin(self): self.assertIn(new_user_name, logined_admins.text) def test_manual_lock_user_token(self): - """Test functionality of locking users by manual command with user token""" + """Test functionality of locking users by manual command with user token + (user should not be locked) + """ + users = InitUsers.users.copy() user, password = users.popitem() # user for login user_to_lock = choice(list(users.keys())) # returning random user for lock @@ -104,7 +129,10 @@ def test_manual_lock_user_token(self): self.assertNotIn(user_to_lock, locked_users_request.text) def test_locking_unexisting_user(self): - """Test functionality of locking unexisting users""" + """Test functionality of locking unexisting user + (unexisting user should not be locked) + """ + fake_user = Users.fake_user fake_password = Users.fake_password for _ in range(3): @@ -114,7 +142,10 @@ def test_locking_unexisting_user(self): self.assertEqual(locked_users, '') def test_get_locked_admins_user_token(self): - """Discovering locked admins with user token""" + """Discovering locked admins with user token + (locked admins should not be displayed) + """ + users = InitUsers.users.copy() user, password = choice(list(users.items())) for _ in range(3): @@ -126,7 +157,10 @@ def test_get_locked_admins_user_token(self): self.assertEqual(locked_admin, '') def test_get_locked_admins_empty_token(self): - """Discovering locked admins with empty token""" + """Discovering locked admins with empty token + (locked admins should not be displayed) + """ + for _ in range(3): self.application.login(DefaultUser.user_admin, Users.fake_password) token = '' @@ -135,7 +169,10 @@ def test_get_locked_admins_empty_token(self): self.assertEqual(locked_admin, '') def test_get_locked_users_user_token(self): - """Discovering locked users with user token""" + """Discovering locked users with user token + (locked users should not be displayed) + """ + users = InitUsers.users.copy() users.pop('admin', None) user, pasword = users.popitem() @@ -148,7 +185,10 @@ def test_get_locked_users_user_token(self): self.assertEqual(locked_users, '') def test_get_locked_users_empty_token(self): - """Discovering locked users with empty token""" + """Discovering locked users with empty token + (locked users should not be displayed) + """ + users = InitUsers.users.copy() users.pop('admin', None) user_to_lock = list(users.keys())[0] From a3dbdee52f9f9d6ba873d1a1d0265619822ff03b Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Mon, 5 Nov 2018 12:52:36 +0200 Subject: [PATCH 68/74] reworked docstrins --- tests/functional/tests_locked.py | 53 ++++++++++++++++++++++++-------- 1 file changed, 40 insertions(+), 13 deletions(-) diff --git a/tests/functional/tests_locked.py b/tests/functional/tests_locked.py index 91ea6ea..71f39f2 100644 --- a/tests/functional/tests_locked.py +++ b/tests/functional/tests_locked.py @@ -1,6 +1,7 @@ """Testing functionality of locking users""" from random import choice + from tests.constants.constants import DefaultUser, InitUsers, NewUser, Users from tests.functional import ApiTestBase @@ -16,7 +17,9 @@ def setUp(self): self.kwargs = {'token': self.admin_token} def test_locked(self): - """Test functionality of locking user""" + """Test functionality of locking user after 3 wrong password attempts (user should be locked) + """ + users = InitUsers.users.copy() user = choice(list(users.keys())) # returning random user wrong_password = Users.fake_password @@ -27,7 +30,9 @@ def test_locked(self): self.assertIn(user, locked_users) def test_not_locked(self): - """User should not be locked""" + """User should not be locked after 2 wrong password attempts (user should not be locked) + """ + users = InitUsers.users.copy() user = choice(list(users.keys())) # returning random user wrong_passwords = ['', 'password'] @@ -38,7 +43,9 @@ def test_not_locked(self): self.assertNotIn(user, locked_users) def test_manual_lock(self): - """Test functionality of locking users by manual command""" + """Test functionality of locking users by manual command with admin token (user should be locked) + """ + users = InitUsers.users.copy() user_to_lock = choice(list(users.keys())) # returning random user self.application.lock_user(self.admin_token, user_to_lock) @@ -46,7 +53,9 @@ def test_manual_lock(self): self.assertIn(user_to_lock, locked_users_request.text) def test_manual_unlock(self): - """Test functionality of unlocking users by manual command""" + """Test functionality of unlocking user by manual command with admin token (user should be unlocked) + """ + users = InitUsers.users.copy() user_to_lock = choice(list(users.keys())) # returning random user wrong_password = Users.fake_password @@ -58,7 +67,9 @@ def test_manual_unlock(self): self.assertNotIn(user_to_lock, locked_users) def test_reset_locked_admin_token(self): - """Test functionality of unlocking all users with admin token""" + """Test functionality of unlocking all users with admin token (all users should be unlocked) + """ + users = InitUsers.users.copy() wrong_password = Users.fake_password for user in users.keys(): @@ -69,7 +80,9 @@ def test_reset_locked_admin_token(self): self.assertEqual(locked_users, '') def test_locked_admins(self): - """Test functionality of locking admins""" + """Test functionality of locking admins after 3 wrong password attempts (admin should be locked) + """ + new_user_name = NewUser.name new_user_pass = NewUser.password self.application.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') @@ -80,7 +93,9 @@ def test_locked_admins(self): self.assertIn(new_user_name, locked_admins.text) def test_not_locked_admin(self): - """Admin should not be locked""" + """Admin should not be locked after 2 wrong password attempts (admin should not be locked) + """ + new_user_name = NewUser.name new_user_pass = NewUser.password self.application.create_new_user(self.admin_token, new_user_name, new_user_pass, 'true') @@ -93,7 +108,9 @@ def test_not_locked_admin(self): self.assertIn(new_user_name, logined_admins.text) def test_manual_lock_user_token(self): - """Test functionality of locking users by manual command with user token""" + """Test functionality of locking users by manual command with user token (user should not be locked) + """ + users = InitUsers.users.copy() user, password = users.popitem() # user for login user_to_lock = choice(list(users.keys())) # returning random user for lock @@ -104,7 +121,9 @@ def test_manual_lock_user_token(self): self.assertNotIn(user_to_lock, locked_users_request.text) def test_locking_unexisting_user(self): - """Test functionality of locking unexisting users""" + """Test functionality of locking unexisting user (unexisting user should not be locked) + """ + fake_user = Users.fake_user fake_password = Users.fake_password for _ in range(3): @@ -114,7 +133,9 @@ def test_locking_unexisting_user(self): self.assertEqual(locked_users, '') def test_get_locked_admins_user_token(self): - """Discovering locked admins with user token""" + """Discovering locked admins with user token (locked admins should not be displayed) + """ + users = InitUsers.users.copy() user, password = choice(list(users.items())) for _ in range(3): @@ -126,7 +147,9 @@ def test_get_locked_admins_user_token(self): self.assertEqual(locked_admin, '') def test_get_locked_admins_empty_token(self): - """Discovering locked admins with empty token""" + """Discovering locked admins with empty token (locked admins should not be displayed) + """ + for _ in range(3): self.application.login(DefaultUser.user_admin, Users.fake_password) token = '' @@ -135,7 +158,9 @@ def test_get_locked_admins_empty_token(self): self.assertEqual(locked_admin, '') def test_get_locked_users_user_token(self): - """Discovering locked users with user token""" + """Discovering locked users with user token (locked users should not be displayed) + """ + users = InitUsers.users.copy() users.pop('admin', None) user, pasword = users.popitem() @@ -148,7 +173,9 @@ def test_get_locked_users_user_token(self): self.assertEqual(locked_users, '') def test_get_locked_users_empty_token(self): - """Discovering locked users with empty token""" + """Discovering locked users with empty token (locked users should not be displayed) + """ + users = InitUsers.users.copy() users.pop('admin', None) user_to_lock = list(users.keys())[0] From 0295c6167b538ea5f0d615d5763712198c082f92 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Mon, 5 Nov 2018 13:12:58 +0200 Subject: [PATCH 69/74] ref. --- tests/functional/tests_user_create_new.py | 32 +++++++++++------------ tests/functional/tests_user_remove.py | 4 +-- 2 files changed, 17 insertions(+), 19 deletions(-) diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index b59cad0..80713df 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -1,9 +1,9 @@ """Testing ability to create new user For getting valid response we need admin token, new user name, new password and give him admin rights""" -from tests.functional import ApiTestBase -from tests.constants.constants import DefaultUser, NewUser, UserToTest, InvalidValues from ddt import ddt, idata +from tests.constants.constants import DefaultUser, InvalidValues, NewUser, UserToTest +from tests.functional import ApiTestBase @ddt @@ -21,7 +21,8 @@ def test_create_new_user(self): """create new user with valid data""" - create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.isUser) + create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, + NewUser.password, NewUser.isUser) self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) @@ -34,9 +35,10 @@ def test_create_new_user(self): def test_create_new_with_exist_name(self): """create new user with already exist name""" - create_new_user = self.application.create_new_user(self.admin_token, DefaultUser.user, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) + create_new_user = self.application.create_new_user(self.admin_token, DefaultUser.user, + NewUser.password, NewUser.isUser) self.assertEqual(200, create_new_user.status_code) + self.assertFalse(create_new_user.json()['content']) # try to login with new user login = self.application.login(DefaultUser.user, NewUser.password) @@ -53,8 +55,8 @@ def test_with_non_admin_token(self): # create new user with user token create_new_user = self.application.create_new_user(user_token, NewUser.name, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) + self.assertFalse(create_new_user.json()['content']) # try to login with new user login_new_user = self.application.login(NewUser.name, NewUser.password) @@ -64,10 +66,10 @@ def test_with_non_admin_token(self): def test_give_invalid_admin_rights(self): """create new user with invalid admin rights""" - create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.wrong_rights) - self.assertIn("Bad Request", create_new_user.text) + create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, + NewUser.password, NewUser.wrong_rights) self.assertEqual(400, create_new_user.status_code) - self.assertNotEqual(200, create_new_user.status_code) + self.assertIn("Bad Request", create_new_user.text) # try to login with new user login = self.application.login(NewUser.name, NewUser.password) @@ -78,26 +80,22 @@ def test_give_invalid_admin_rights(self): def test_wrong_new_login(self, value): """create new user with spaces on login""" - # login_with_space = InvalidValues.values[0] create_new_user = self.application.create_new_user(self.admin_token, value, NewUser.password, NewUser.isUser) - self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) + self.assertTrue(create_new_user.json()['content']) # try to login with new user login = self.application.login(value, NewUser.password) - len_of_new_user_token = len(login.json()['content']) - self.assertNotEqual(32, len_of_new_user_token, "Wrong login name: " + value) + self.assertIn("ERROR, user not found", login.text, "User {} was found".format(value)) @idata(InvalidValues.values) def test_wrong_new_pass(self, value): """create new user with only spaces on login""" - create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, value, NewUser.isUser) - self.assertTrue(create_new_user.text) self.assertEqual(200, create_new_user.status_code) + self.assertFalse(create_new_user.json()['content']) # try to login with new user login = self.application.login(NewUser.name, value) - len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with wrong pass: " + value) + self.assertIn("ERROR, user not found", login.text, "User {} was found".format(value)) diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py index cd1bdcf..febe844 100644 --- a/tests/functional/tests_user_remove.py +++ b/tests/functional/tests_user_remove.py @@ -2,7 +2,7 @@ For getting valid response we need admin token and user name""" from tests.functional import ApiTestBase -from tests.constants.constants import DefaultUser, UserToTest, InvalidValues, DefaultToken +from tests.constants.constants import DefaultUser, DefaultToken, InvalidValues, UserToTest class TestRemoveUser(ApiTestBase): @@ -49,8 +49,8 @@ def test_admin_delete_himself(self): removed_user = self.application.delete_user(self.admin_token, DefaultUser.user) get_answer = str(removed_user.json()['content']) - self.assertIn('True', get_answer) self.assertEqual(200, removed_user.status_code) + self.assertIn('True', get_answer) # search user in user list get_user_list = self.application.get_all_users(self.admin_token) From 50d42ece391d240c1a6c4a417d1db3a66e759f9b Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Tue, 6 Nov 2018 11:43:32 +0200 Subject: [PATCH 70/74] fixing docstrings add tests for login, logout, admins with empty token --- tests/functional/tests_admins.py | 14 +++++--- tests/functional/tests_login.py | 47 +++++++++++++++++-------- tests/functional/tests_logout.py | 31 +++++++++++----- tests/functional/tests_tokenlifetime.py | 6 ++-- 4 files changed, 68 insertions(+), 30 deletions(-) diff --git a/tests/functional/tests_admins.py b/tests/functional/tests_admins.py index 3089a25..070203f 100644 --- a/tests/functional/tests_admins.py +++ b/tests/functional/tests_admins.py @@ -1,6 +1,6 @@ """Functional tests for admins""" -from tests.constants.constants import Users, DefaultUser, DefaultToken, VALID_STATUS_CODE +from tests.constants.constants import DefaultToken, DefaultUser, Users, VALID_STATUS_CODE from tests.functional import ApiTestBase @@ -8,7 +8,7 @@ class TestAdmins(ApiTestBase): """Class for testing""" def test_admins(self): - """Get all admins with admin token. If list not empty test pass.""" + """Get all admins with admin token. If list not empty test pass (positive)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) all_admins = self.application.admins(login.json().get("content")) @@ -16,7 +16,7 @@ def test_admins(self): self.assertTrue(all_admins.json().get("content"), "Content is empty") def test_admins_user(self): - """Get all admins without admin token. If list empty test pass""" + """Get all admins with user token. If list empty test pass (positive)""" login = self.application.login(Users.valid_user, Users.valid_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) all_admins = self.application.admins(login.json().get("content")) @@ -24,7 +24,13 @@ def test_admins_user(self): self.assertFalse(all_admins.json().get("content"), "Content is not empty") def test_admins_default_token(self): - """Get all admins with default token. If list empty test pass""" + """Get all admins with default token. If list empty test pass (negative)""" all_admins = self.application.admins(DefaultToken.token) self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) self.assertFalse(all_admins.json().get("content"), "Content is not empty") + + def test_admins_empty_token(self): + """Get all admins with empty token. If list empty test pass (negative)""" + all_admins = self.application.admins("") + self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) + self.assertFalse(all_admins.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py index c6fdf38..4737e1d 100644 --- a/tests/functional/tests_login.py +++ b/tests/functional/tests_login.py @@ -1,6 +1,6 @@ """Functional tests for logging users""" -from tests.constants.constants import DefaultUser, Users, DefaultToken, VALID_STATUS_CODE +from tests.constants.constants import DefaultToken, DefaultUser, Users, VALID_STATUS_CODE from tests.functional import ApiTestBase @@ -8,34 +8,33 @@ class TestLogin(ApiTestBase): """Class for testing""" def test_login(self): - """Login user. If user got token test pass.""" + """Login user. If user got token test pass (positive)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertEqual(len(login.json().get("content")), 32, "Invalid token") def test_login_user_not_found(self): - """Login fake user name. If user not found test pass.""" + """Login fake user name. If user not found test pass (negative)""" login = self.application.login(Users.fake_user, Users.fake_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertIn("ERROR, user not found", login.text, "User founded") def test_login_user_locked(self): - """Login 4 times with fake password to lock. If user locked test pass.""" + """Login 4 times with valid user and fake password to lock. If user locked test pass (negative)""" for _ in range(4): login = self.application.login(Users.valid_user, Users.fake_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertIn("ERROR, user locked", login.text, "User not locked") def test_login_fake_user_locked(self): - """Login 4 times with fake user to lock. If user not found test pass.""" + """Login 4 times with fake user and password to lock. If user not found test pass (negative)""" for _ in range(4): login = self.application.login(Users.fake_user, Users.fake_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) self.assertIn("ERROR, user not found", login.text, "User locked") def test_login_admins(self): - """Get logged admins with admin token. - If user had admin rights and got the list of logged admins test pass.""" + """Get logged admins with admin token. If got the list of logged admins test pass (positive)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logged_admins = self.application.login_admins(login.json().get("content")) @@ -43,7 +42,7 @@ def test_login_admins(self): self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_admins_user(self): - """Get logged admins without admin token. If empty response test pass.""" + """Get logged admins with user token. If empty response test pass (positive)""" login = self.application.login(Users.valid_user, Users.valid_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logged_admins = self.application.login_admins(login.json().get("content")) @@ -51,13 +50,19 @@ def test_login_admins_user(self): self.assertFalse(logged_admins.json().get("content"), "Content is not empty") def test_login_admins_default_token(self): - """Get logged admins with default token. If empty response test pass.""" + """Get logged admins with default token. If empty response test pass (negative)""" logged_admins = self.application.login_admins(DefaultToken.token) self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + def test_login_admins_empty_token(self): + """Get logged admins with empty token. If empty response test pass (negative)""" + logged_admins = self.application.login_admins("") + self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) + self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + def test_login_users_admin(self): - """Get logged users with admin token. If got the list of logged users test pass.""" + """Get logged users with admin token. If got the list of logged users test pass (positive)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logged_admins = self.application.login_users(login.json().get("content")) @@ -65,7 +70,7 @@ def test_login_users_admin(self): self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_users(self): - """Get logged users without admin token. If list of users empty test pass.""" + """Get logged users with user token. If list of users empty test pass (positive)""" login = self.application.login(Users.valid_user, Users.valid_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logged_users = self.application.login_users(login.json().get("content")) @@ -73,13 +78,19 @@ def test_login_users(self): self.assertFalse(logged_users.json().get("content"), "Content is not empty") def test_login_users_default_token(self): - """Get logged users without admin token. If list of users empty test pass.""" + """Get logged users with default token. If list of users empty test pass (negative)""" logged_users = self.application.login_users(DefaultToken.token) self.assertEqual(VALID_STATUS_CODE, logged_users.status_code) self.assertFalse(logged_users.json().get("content"), "Content is not empty") + def test_login_users_empty_token(self): + """Get logged users with empty token. If list of users empty test pass (negative)""" + logged_users = self.application.login_users("") + self.assertEqual(VALID_STATUS_CODE, logged_users.status_code) + self.assertFalse(logged_users.json().get("content"), "Content is not empty") + def test_login_tockens_admin(self): - """Get alive tockens with admin token. If got list of tokens test pass.""" + """Get alive tockens with admin token. If got list of tokens test pass (positive)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) alive_tokens = self.application.login_tockens(login.json().get("content")) @@ -87,7 +98,7 @@ def test_login_tockens_admin(self): self.assertTrue(alive_tokens.json().get("content"), "Content is empty") def test_login_tockens_users(self): - """Get alive tockens without admin token. If list of tokens empty test pass""" + """Get alive tockens with user token. If list of tokens empty test pass (positive)""" login = self.application.login(Users.valid_user, Users.valid_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) alive_tokens = self.application.login_tockens(login.json().get("content")) @@ -95,7 +106,13 @@ def test_login_tockens_users(self): self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") def test_login_tockens_users_default_token(self): - """Get alive tockens with default token. If list of tokens empty test pass""" + """Get alive tockens with default token. If list of tokens empty test pass (negative)""" + alive_tokens = self.application.login_tockens(DefaultToken.token) + self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) + self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") + + def test_login_tockens_users_empty_token(self): + """Get alive tockens with empty token. If list of tokens empty test pass (negative)""" alive_tokens = self.application.login_tockens(DefaultToken.token) self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_logout.py b/tests/functional/tests_logout.py index 6dcbd34..c30b822 100644 --- a/tests/functional/tests_logout.py +++ b/tests/functional/tests_logout.py @@ -1,6 +1,6 @@ """Functional tests for logout users""" -from tests.constants.constants import DefaultUser, Users, DefaultToken, VALID_STATUS_CODE +from tests.constants.constants import DefaultToken, DefaultUser, Users, VALID_STATUS_CODE from tests.functional import ApiTestBase @@ -8,16 +8,32 @@ class TestLogout(ApiTestBase): """Class for testing""" def test_logout(self): - """Logout user. If request true and user logout test pass.""" + """Logout user. If request true test pass (positive)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) + logged_admins = self.application.login_admins(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) + self.assertTrue(logged_admins.json().get("content"), "Content is empty") logout = self.application.logout(DefaultUser.user, login.json().get("content")) self.assertEqual(VALID_STATUS_CODE, logout.status_code) self.assertTrue(logout.json().get("content"), "User not logout") + logged_admins = self.application.login_admins(login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) + self.assertFalse(logged_admins.json().get("content"), "Content is not empty") + + def test_double_logout(self): + """Double logout user. If request true than false test pass (negative)""" + login = self.application.login(DefaultUser.user, DefaultUser.password) + self.assertEqual(VALID_STATUS_CODE, login.status_code) + logout1 = self.application.logout(DefaultUser.user, login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logout1.status_code) + self.assertTrue(logout1.json().get("content"), "User not logout") + logout2 = self.application.logout(DefaultUser.user, login.json().get("content")) + self.assertEqual(VALID_STATUS_CODE, logout2.status_code) + self.assertFalse(logout2.json().get("content"), "User not logout") def test_logout_another_user(self): - """Login user1, logout another user2 with user1 token. - If request false and user2 didn't logout test pass.""" + """Login user1, logout another user2 with user1 token. If user2 didn't logout test pass (negative)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logout = self.application.logout(Users.valid_user, login.json().get("content")) @@ -25,8 +41,7 @@ def test_logout_another_user(self): self.assertFalse(logout.json().get("content"), "User logout") def test_logout_another_token(self): - """Login user, logout with another token. - If request false and user didn't logout test pass.""" + """Login user, logout with another token. If user didn't logout test pass (negative)""" login = self.application.login(DefaultUser.user, DefaultUser.password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logout = self.application.logout(DefaultUser.user, DefaultToken.token) @@ -34,7 +49,7 @@ def test_logout_another_token(self): self.assertFalse(logout.json().get("content"), "User logout") def test_logout_fake_users(self): - """Logout fake user. If request false and user didn't logout test pass.""" + """Logout fake user. If user didn't logout test pass (negative)""" login = self.application.login(Users.fake_user, Users.fake_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logout = self.application.logout(Users.fake_user, login.json().get("content")) @@ -42,7 +57,7 @@ def test_logout_fake_users(self): self.assertFalse(logout.json().get("content"), "User logout") def test_logout_locked_users(self): - """Logout locked user. If request false user didn't logout and test pass.""" + """Logout locked user. If user didn't logout and test pass (negative)""" for _ in range(4): login = self.application.login(Users.valid_user, Users.fake_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py index 6855cad..5ffc09a 100644 --- a/tests/functional/tests_tokenlifetime.py +++ b/tests/functional/tests_tokenlifetime.py @@ -2,8 +2,8 @@ Testing response of "/tokenlifetime" module """ -from tests.functional import ApiTestBase from tests.constants.constants import DefaultUser +from tests.functional import ApiTestBase from tests.utils.helper import get_new_value_different_func @@ -14,7 +14,7 @@ class TestTokenLifeTime(ApiTestBase): def test_get_token_life_time(self): """ - Get the value of token life time + Get the value of token life time. If got tlt or tlt = 0 test pass (positive) """ resp = self.application.get_token_life_time() @@ -24,7 +24,7 @@ def test_get_token_life_time(self): def test_set_token_life_time_admin_positive(self): """ - Change the token life time value by admin (positive) + Change the token life time value by admin. If tlt changed test pass (positive) """ new_tlt = get_new_value_different_func(self.application.get_token_life_time, 200000, 100000) From 12886a5cf5b37fe64a00f43fee98227443228d61 Mon Sep 17 00:00:00 2001 From: ohrytsiuk Date: Tue, 6 Nov 2018 18:37:10 +0200 Subject: [PATCH 71/74] add ddt for some tests docstring fixes --- tests/functional/tests_admins.py | 18 +++++----- tests/functional/tests_login.py | 46 +++++++++---------------- tests/functional/tests_tokenlifetime.py | 23 +++++++------ 3 files changed, 37 insertions(+), 50 deletions(-) diff --git a/tests/functional/tests_admins.py b/tests/functional/tests_admins.py index 070203f..f08aa33 100644 --- a/tests/functional/tests_admins.py +++ b/tests/functional/tests_admins.py @@ -1,9 +1,12 @@ """Functional tests for admins""" +from ddt import data, ddt + from tests.constants.constants import DefaultToken, DefaultUser, Users, VALID_STATUS_CODE from tests.functional import ApiTestBase +@ddt class TestAdmins(ApiTestBase): """Class for testing""" @@ -16,21 +19,16 @@ def test_admins(self): self.assertTrue(all_admins.json().get("content"), "Content is empty") def test_admins_user(self): - """Get all admins with user token. If list empty test pass (positive)""" + """Get all admins with user token. If list empty test pass (negative)""" login = self.application.login(Users.valid_user, Users.valid_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) all_admins = self.application.admins(login.json().get("content")) self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) self.assertFalse(all_admins.json().get("content"), "Content is not empty") - def test_admins_default_token(self): - """Get all admins with default token. If list empty test pass (negative)""" - all_admins = self.application.admins(DefaultToken.token) - self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) - self.assertFalse(all_admins.json().get("content"), "Content is not empty") - - def test_admins_empty_token(self): - """Get all admins with empty token. If list empty test pass (negative)""" - all_admins = self.application.admins("") + @data(DefaultToken.token, "") + def test_admins_token(self, value): + """Get all admins with default and empty token. If list empty test pass (negative)""" + all_admins = self.application.admins(value) self.assertEqual(VALID_STATUS_CODE, all_admins.status_code) self.assertFalse(all_admins.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_login.py b/tests/functional/tests_login.py index 4737e1d..dcda788 100644 --- a/tests/functional/tests_login.py +++ b/tests/functional/tests_login.py @@ -1,9 +1,12 @@ """Functional tests for logging users""" +from ddt import data, ddt + from tests.constants.constants import DefaultToken, DefaultUser, Users, VALID_STATUS_CODE from tests.functional import ApiTestBase +@ddt class TestLogin(ApiTestBase): """Class for testing""" @@ -49,15 +52,10 @@ def test_login_admins_user(self): self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) self.assertFalse(logged_admins.json().get("content"), "Content is not empty") - def test_login_admins_default_token(self): - """Get logged admins with default token. If empty response test pass (negative)""" - logged_admins = self.application.login_admins(DefaultToken.token) - self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) - self.assertFalse(logged_admins.json().get("content"), "Content is not empty") - - def test_login_admins_empty_token(self): - """Get logged admins with empty token. If empty response test pass (negative)""" - logged_admins = self.application.login_admins("") + @data(DefaultToken.token, "") + def test_login_admins_token(self, value): + """Get logged admins with default and empty token. If empty response test pass (negative)""" + logged_admins = self.application.login_admins(value) self.assertEqual(VALID_STATUS_CODE, logged_admins.status_code) self.assertFalse(logged_admins.json().get("content"), "Content is not empty") @@ -70,22 +68,17 @@ def test_login_users_admin(self): self.assertTrue(logged_admins.json().get("content"), "Content is empty") def test_login_users(self): - """Get logged users with user token. If list of users empty test pass (positive)""" + """Get logged users with user token. If list of users empty test pass (negative)""" login = self.application.login(Users.valid_user, Users.valid_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) logged_users = self.application.login_users(login.json().get("content")) self.assertEqual(VALID_STATUS_CODE, logged_users.status_code) self.assertFalse(logged_users.json().get("content"), "Content is not empty") - def test_login_users_default_token(self): - """Get logged users with default token. If list of users empty test pass (negative)""" - logged_users = self.application.login_users(DefaultToken.token) - self.assertEqual(VALID_STATUS_CODE, logged_users.status_code) - self.assertFalse(logged_users.json().get("content"), "Content is not empty") - - def test_login_users_empty_token(self): - """Get logged users with empty token. If list of users empty test pass (negative)""" - logged_users = self.application.login_users("") + @data(DefaultToken.token, "") + def test_login_users_token(self, value): + """Get logged users with default and empty token. If list of users empty test pass (negative)""" + logged_users = self.application.login_users(value) self.assertEqual(VALID_STATUS_CODE, logged_users.status_code) self.assertFalse(logged_users.json().get("content"), "Content is not empty") @@ -98,21 +91,16 @@ def test_login_tockens_admin(self): self.assertTrue(alive_tokens.json().get("content"), "Content is empty") def test_login_tockens_users(self): - """Get alive tockens with user token. If list of tokens empty test pass (positive)""" + """Get alive tockens with user token. If list of tokens empty test pass (negative)""" login = self.application.login(Users.valid_user, Users.valid_password) self.assertEqual(VALID_STATUS_CODE, login.status_code) alive_tokens = self.application.login_tockens(login.json().get("content")) self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") - def test_login_tockens_users_default_token(self): - """Get alive tockens with default token. If list of tokens empty test pass (negative)""" - alive_tokens = self.application.login_tockens(DefaultToken.token) - self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) - self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") - - def test_login_tockens_users_empty_token(self): - """Get alive tockens with empty token. If list of tokens empty test pass (negative)""" - alive_tokens = self.application.login_tockens(DefaultToken.token) + @data(DefaultToken.token, "") + def test_login_tockens_users_token(self, value): + """Get alive tockens with default and empty token. If list of tokens empty test pass (negative)""" + alive_tokens = self.application.login_tockens(value) self.assertEqual(VALID_STATUS_CODE, alive_tokens.status_code) self.assertFalse(alive_tokens.json().get("content"), "Content is not empty") diff --git a/tests/functional/tests_tokenlifetime.py b/tests/functional/tests_tokenlifetime.py index 5ffc09a..21e263c 100644 --- a/tests/functional/tests_tokenlifetime.py +++ b/tests/functional/tests_tokenlifetime.py @@ -14,17 +14,18 @@ class TestTokenLifeTime(ApiTestBase): def test_get_token_life_time(self): """ - Get the value of token life time. If got tlt or tlt = 0 test pass (positive) + Get the value of token life time. If got tlt test pass (positive) """ resp = self.application.get_token_life_time() self.assertEqual(resp.status_code, 200) - self.assertTrue(resp.json()["content"] or resp.json()["content"] == 0) + # self.assertTrue(resp.json()["content"] or resp.json()["content"] == 0) + self.assertTrue(resp.json()["content"]) def test_set_token_life_time_admin_positive(self): """ - Change the token life time value by admin. If tlt changed test pass (positive) + Change the token life time value by admin (200000). If tlt changed test pass (positive) """ new_tlt = get_new_value_different_func(self.application.get_token_life_time, 200000, 100000) @@ -43,7 +44,7 @@ def test_set_token_life_time_admin_positive(self): def test_set_token_life_time_admin_negative(self): """ - Change the token life time value by admin (negative) + Change the token life time value by admin (-200000). If tft not changed test pass (negative) """ new_tlt = get_new_value_different_func(self.application.get_token_life_time, -200000, -100000) @@ -58,11 +59,11 @@ def test_set_token_life_time_admin_negative(self): self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(tlt_after, new_tlt) + self.assertNotEqual(tlt_after, new_tlt) def test_set_token_life_time_admin_zero(self): """ - Change the token life time value by admin (zero) + Change the token life time value by admin (zero). If tlt changed test pass (positive) """ new_tlt = get_new_value_different_func(self.application.get_token_life_time, 0, 0) @@ -77,11 +78,11 @@ def test_set_token_life_time_admin_zero(self): self.assertEqual(resp.status_code, 200) self.assertTrue(resp.json()["content"]) - self.assertEqual(tlt_after, new_tlt) + self.assertNotEqual(tlt_after, new_tlt) def test_set_token_life_time_admin_none(self): """ - Change the token life time value by admin (None) + Change the token life time value by admin (None). If tlt stand 1000 (default value) test pass (negative) """ new_tlt = None @@ -101,7 +102,7 @@ def test_set_token_life_time_admin_none(self): def test_set_token_life_time_admin_float(self): """ - Change the token life time value by admin (float) + Change the token life time value by admin (float 200000.555). If tlt didn't change test pass (negative) """ new_tlt = get_new_value_different_func(self.application.get_token_life_time, 200000.555, 100000) @@ -122,7 +123,7 @@ def test_set_token_life_time_admin_float(self): def test_set_token_life_time_admin_text(self): """ - Change the token life time value by admin (text) + Change the token life time value by admin (text). If tlt didn't change test pass (negative) """ new_tlt = "f%kdm525!(" @@ -143,7 +144,7 @@ def test_set_token_life_time_admin_text(self): def test_set_token_life_time_user(self): """ - Change the token life time value by user (without admin rights) + Change the token life time value by user (without admin rights). If tlt didn't change test pass (negative) """ new_tlt = get_new_value_different_func(self.application.get_token_life_time, 500000, 100000) From f92dc2e4f67e6c6ad91615bfe89b91977e46c4bc Mon Sep 17 00:00:00 2001 From: Pavlo Bezrukov Date: Tue, 6 Nov 2018 20:19:35 +0200 Subject: [PATCH 72/74] refactoring docstrings --- tests/functional/tests_add_item.py | 14 +++++++++--- tests/functional/tests_all_items.py | 3 +-- tests/functional/tests_delete_item.py | 16 +++++++------- tests/functional/tests_get_all_items_user.py | 8 +++---- tests/functional/tests_get_item_by_index.py | 4 ++-- tests/functional/tests_get_item_indexes.py | 2 +- .../tests_get_user_item_by_index.py | 4 ++-- tests/functional/tests_update_item.py | 22 +++++++++---------- 8 files changed, 40 insertions(+), 33 deletions(-) diff --git a/tests/functional/tests_add_item.py b/tests/functional/tests_add_item.py index 9052686..4a375d0 100644 --- a/tests/functional/tests_add_item.py +++ b/tests/functional/tests_add_item.py @@ -34,21 +34,29 @@ def test_add_specific_item(self): self.assertEqual(ITEM_NAME, get_item_response.json()["content"]) def test_add_item_negative(self): - """Test add item with invalid token""" + """Test can not add item with invalid token""" add_item_user_response = self.application.add_item(ITEM_INDEX, INVALID_TOKEN, ITEM_NAME) self.assertEqual(VALID_STATUS_CODE, add_item_user_response.status_code) self.assertFalse(add_item_user_response.json()["content"]) def test_add_item_invalid_index(self): - """Test add item when index not int""" + """Test can not add item when index not int""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] add_item_user_response = self.application.add_item(ITEM_NAME, token, ITEM_NAME) self.assertNotEqual(VALID_STATUS_CODE, add_item_user_response.status_code) + def test_add_item_invalid_index1(self): + """Test can not add item when index four zeros""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.application.login(user, password).json()["content"] + add_item_user_response = self.application.add_item(0000, token, ITEM_NAME) + self.assertNotEqual(VALID_STATUS_CODE, add_item_user_response.status_code) + def test_add_int_item(self): - """Test add item with only number""" + """Test can not add item with only numbers""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] diff --git a/tests/functional/tests_all_items.py b/tests/functional/tests_all_items.py index bec34d5..44fa1da 100644 --- a/tests/functional/tests_all_items.py +++ b/tests/functional/tests_all_items.py @@ -7,7 +7,6 @@ class TestAllItems(ApiTestBase): """Class for tests of all items""" - def test_without_items(self): """Test get all items when user has not any items""" for user, password in InitUsers.users.items(): @@ -30,7 +29,7 @@ def test_with_items(self): self.assertTrue(get_all_items_response.json()["content"]) def test_items_by_invalid_token(self): - """Test get all items with invalid token""" + """Test can not get all items with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] diff --git a/tests/functional/tests_delete_item.py b/tests/functional/tests_delete_item.py index 8b5ce44..378f5f6 100644 --- a/tests/functional/tests_delete_item.py +++ b/tests/functional/tests_delete_item.py @@ -13,27 +13,27 @@ class TestDeleteItem(ApiTestBase): """Class for tests of delete item""" - def test_delete_empty_item(self): - """Test delete item when user has not any items""" + def test_delete_item(self): + """Test delete item when user has item""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] + self.application.add_item(ITEM_INDEX, token, ITEM_NAME) delete_item_response = self.application.delete_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) - self.assertFalse(delete_item_response.json()["content"]) + self.assertTrue(delete_item_response.json()["content"]) - def test_delete_item(self): - """Test delete item when user has item""" + def test_delete_empty_item(self): + """Test can not delete item when user has not any items""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] - self.application.add_item(ITEM_INDEX, token, ITEM_NAME) delete_item_response = self.application.delete_item(ITEM_INDEX, token) self.assertEqual(VALID_STATUS_CODE, delete_item_response.status_code) - self.assertTrue(delete_item_response.json()["content"]) + self.assertFalse(delete_item_response.json()["content"]) def test_delete_item_invalid_token(self): - """Test delete item with invalid token""" + """Test can not delete item with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] diff --git a/tests/functional/tests_get_all_items_user.py b/tests/functional/tests_get_all_items_user.py index d6fdcef..4053734 100644 --- a/tests/functional/tests_get_all_items_user.py +++ b/tests/functional/tests_get_all_items_user.py @@ -23,7 +23,7 @@ def test_get_items_by_admin(self): self.assertFalse(get_items_user_response.json()["content"]) def test_get_items_by_admin_with_invalid_token(self): - """Test get items by admin with invalid token""" + """Test can not get items by admin with invalid token""" self.application.login(DefaultUser.user, DefaultUser.password) for user in InitUsers.users: with self.subTest(i=user): @@ -44,14 +44,14 @@ def test_get_added_items_by_admin(self): self.assertTrue(get_items_user_response.json()["content"]) def test_get_items_invalid_user(self): - """Test get item invalid user""" + """Test can not get item invalid user""" admin_token = self.application.login(DefaultUser.user, DefaultUser.password).json()["content"] get_items_user_response = self.application.get_user_all_items(ITEM_NAME, admin_token) self.assertNotEqual(VALID_STATUS_CODE, get_items_user_response.status_code) self.assertIn("Error", get_items_user_response.text) def test_get_items_by_user(self): - """Test get user items with user token""" + """Test can not get user items with user token""" for user in InitUsers.users: with self.subTest(i=user): token = self.application.login("kilinatc", "qwerty").json()["content"] @@ -60,7 +60,7 @@ def test_get_items_by_user(self): self.assertFalse(get_items_user_response.json()["content"]) def test_get_added_items_by_user(self): - """Test get added user items by user token""" + """Test can not get added user items by user token""" for user, password in InitUsers.users.items(): token = self.application.login(user, password).json()["content"] self.application.add_item(ITEM_INDEX, token, ITEM_NAME) diff --git a/tests/functional/tests_get_item_by_index.py b/tests/functional/tests_get_item_by_index.py index fc8042b..235725d 100644 --- a/tests/functional/tests_get_item_by_index.py +++ b/tests/functional/tests_get_item_by_index.py @@ -34,7 +34,7 @@ def test_get_item(self): self.assertEqual(ITEM_NAME, get_item_response.json()["content"]) def test_get_item_index_str(self): - """Test get item by index with str index""" + """Test can not get item by index when index consists of letters""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] @@ -44,7 +44,7 @@ def test_get_item_index_str(self): self.assertIn("Bad Request", get_item_response.text) def test_get_item_index_invalid_token(self): - """Test get item by index with invalid token""" + """Test can not get item by index with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): self.application.login(user, password) diff --git a/tests/functional/tests_get_item_indexes.py b/tests/functional/tests_get_item_indexes.py index 9ce2001..39f25de 100644 --- a/tests/functional/tests_get_item_indexes.py +++ b/tests/functional/tests_get_item_indexes.py @@ -33,7 +33,7 @@ def test_get_item_indexes(self): self.assertTrue(get_item_indexes_response.json()["content"]) def test_get_item_indexes_by_invalid_token(self): - """Test get item indexes with invalid token""" + """Test can not get item indexes with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] diff --git a/tests/functional/tests_get_user_item_by_index.py b/tests/functional/tests_get_user_item_by_index.py index 92df957..25b5c25 100644 --- a/tests/functional/tests_get_user_item_by_index.py +++ b/tests/functional/tests_get_user_item_by_index.py @@ -21,7 +21,7 @@ def test_get_user_item_by_admin(self): self.assertFalse(get_item_user_response.json()["content"]) def test_get_user_item_by_user(self): - """Test get user item by index with user token""" + """Test can not get user item by index with user token""" counter = 0 for user, password in InitUsers.users.items(): token = self.application.login(user, password).json()["content"] @@ -31,7 +31,7 @@ def test_get_user_item_by_user(self): self.assertFalse(get_item_user_response.json()["content"]) def test_get_user_item_by_invalid_token(self): - """Test get user item by index with invalid token""" + """Test can not get user item by index with invalid token""" for user in dict.keys(InitUsers.users): self.application.login(DefaultUser.user, DefaultUser.password) get_item_user_response = self.application.get_user_item_by_index(ITEM_INDEX, user, INVALID_TOKEN) diff --git a/tests/functional/tests_update_item.py b/tests/functional/tests_update_item.py index bb5c62e..fb3d8f1 100644 --- a/tests/functional/tests_update_item.py +++ b/tests/functional/tests_update_item.py @@ -13,15 +13,6 @@ class TestUpdateItem(ApiTestBase): """Class for tests of update item""" - def test_update_empty_item(self): - """Test update item when user has no item""" - for user, password in InitUsers.users.items(): - with self.subTest(i=user): - token = self.application.login(user, password).json()["content"] - update_item_response = self.application.update_item(ITEM_INDEX, token, ITEM_NAME) - self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) - self.assertFalse(update_item_response.json()["content"]) - def test_update_item(self): """Test update item when user has item""" for user, password in InitUsers.users.items(): @@ -31,8 +22,17 @@ def test_update_item(self): self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) self.assertTrue(update_item_response.json()["content"]) + def test_update_empty_item(self): + """Test can not update item when user has no item""" + for user, password in InitUsers.users.items(): + with self.subTest(i=user): + token = self.application.login(user, password).json()["content"] + update_item_response = self.application.update_item(ITEM_INDEX, token, ITEM_NAME) + self.assertEqual(VALID_STATUS_CODE, update_item_response.status_code) + self.assertFalse(update_item_response.json()["content"]) + def test_update_item_invalid_index(self): - """Test update item when index not int""" + """Test can not update item when index not int""" for user, password in InitUsers.users.items(): with self.subTest(i=user): token = self.application.login(user, password).json()["content"] @@ -42,7 +42,7 @@ def test_update_item_invalid_index(self): self.assertIn("Bad Request", update_item_response.text) def test_update_item_invalid_token(self): - """Test update item with invalid token""" + """Test can not update item with invalid token""" for user, password in InitUsers.users.items(): with self.subTest(i=user): self.application.login(user, password) From 7aa82846fe5e39ac2d8ab78f91a49aa4ca8d48e1 Mon Sep 17 00:00:00 2001 From: Shtepsel Date: Tue, 6 Nov 2018 22:45:08 +0200 Subject: [PATCH 73/74] docstring in cooldown time test updated --- tests/functional/tests_cooldowntime.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/tests/functional/tests_cooldowntime.py b/tests/functional/tests_cooldowntime.py index d1eff4d..4a8ad21 100644 --- a/tests/functional/tests_cooldowntime.py +++ b/tests/functional/tests_cooldowntime.py @@ -14,7 +14,7 @@ class TestCoolDownTime(ApiTestBase): def test_get_cool_down_time(self): """ - Get the value of cool down time + Get the value of cool down time (positive test) """ resp = self.application.get_cool_down_time() @@ -24,7 +24,7 @@ def test_get_cool_down_time(self): def test_set_cool_down_time_admin_positive(self): """ - Change the cool down time value by admin (positive) + Change the cool down time value by admin (positive test) """ new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 200000, 100000) @@ -43,7 +43,7 @@ def test_set_cool_down_time_admin_positive(self): def test_set_cool_down_time_admin_negative(self): """ - Change the cool down time value by admin (negative) + Change the cool down time value by admin with invalid value (negative test) """ new_cdt = get_new_value_different_func(self.application.get_cool_down_time, -200000, -100000) @@ -62,7 +62,7 @@ def test_set_cool_down_time_admin_negative(self): def test_set_cool_down_time_admin_zero(self): """ - Change the cool down time value by admin (zero) + Change the cool down time value by admin to zero (positive test) """ new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 0, 0) @@ -81,7 +81,7 @@ def test_set_cool_down_time_admin_zero(self): def test_set_cool_down_time_admin_none(self): """ - Change the cool down time value by admin (None) + Change the cool down time value by admin to None (negative test) """ new_cdt = None @@ -101,7 +101,7 @@ def test_set_cool_down_time_admin_none(self): def test_set_cool_down_time_admin_float(self): """ - Change the cool down time value by admin (float) + Change the cool down time value by admin to float value (negative test) """ new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 200000.555, 100000) @@ -122,7 +122,7 @@ def test_set_cool_down_time_admin_float(self): def test_set_cool_down_time_admin_text(self): """ - Change the cool down time value by admin (text) + Change the cool down time value by admin to text (negative test) """ new_cdt = "f%kdm525!(" @@ -143,7 +143,7 @@ def test_set_cool_down_time_admin_text(self): def test_set_cool_down_time_user(self): """ - Change the cool down time value by user (without admin rights) + Change the cool down time value by user (negative test) """ new_cdt = get_new_value_different_func(self.application.get_cool_down_time, 500000, 100000) From 819a2ce7518a8191fc7ff40036f14c08564f5bd5 Mon Sep 17 00:00:00 2001 From: Serhii Heneralchuk Date: Wed, 7 Nov 2018 08:44:44 +0200 Subject: [PATCH 74/74] changed some asserts in tests, edoted doc strings --- tests/functional/tests_get_user_name.py | 4 ++-- tests/functional/tests_user_change_pass.py | 9 ++++---- tests/functional/tests_user_create_new.py | 25 +++++++++++----------- tests/functional/tests_user_remove.py | 17 ++++++++------- 4 files changed, 29 insertions(+), 26 deletions(-) diff --git a/tests/functional/tests_get_user_name.py b/tests/functional/tests_get_user_name.py index c116ad3..ac50b78 100644 --- a/tests/functional/tests_get_user_name.py +++ b/tests/functional/tests_get_user_name.py @@ -15,7 +15,7 @@ def setUp(self): self.assertEqual(200, response.status_code, "login error") def test_get_user_name(self): - """Getting logged in name with existing user""" + """Getting logged in name with existing user(positive)""" # get user name from response response = self.application.get_user_name(self.token) @@ -24,7 +24,7 @@ def test_get_user_name(self): self.assertEqual(UserToTest.login, returned_user_name) def test_invalid_token(self): - """Get username with invalid token""" + """Get username with invalid token(negative)""" wrong_token = self.token + "WK" diff --git a/tests/functional/tests_user_change_pass.py b/tests/functional/tests_user_change_pass.py index 766585e..6a5e3e3 100644 --- a/tests/functional/tests_user_change_pass.py +++ b/tests/functional/tests_user_change_pass.py @@ -25,7 +25,8 @@ def test_change_pass_valid_data(self): new_pass = UserToTest.password + "wk" change_pass = self.application.change_pass(self.token, UserToTest.password, new_pass) self.assertEqual(200, change_pass.status_code) - self.assertTrue(change_pass.text) + self.assertIn("true", change_pass.text) + # login with changed pass login_with_new_pass = self.application.login(UserToTest.login, new_pass) @@ -35,15 +36,15 @@ def test_change_pass_valid_data(self): @idata(InvalidValues.values) def test_change_pass(self, value): - """Change pass with invalid values""" + """Change pass with invalid values(negative)""" # change pass change_pass = self.application.change_pass(self.token, UserToTest.password, value) self.assertEqual(200, change_pass.status_code) - self.assertTrue(change_pass.text) + self.assertNotIn('true', change_pass.text) # login with changed pass login_with_new_pass = self.application.login(UserToTest.login, value) len_token = len(login_with_new_pass.json()['content']) self.assertEqual(200, login_with_new_pass.status_code) - self.assertNotEqual(32, len_token, "Pass changed to wrong: " + value) + self.assertIn("ERROR, user not found", len_token, "Pass changed to wrong: " + value) diff --git a/tests/functional/tests_user_create_new.py b/tests/functional/tests_user_create_new.py index 80713df..92803f7 100644 --- a/tests/functional/tests_user_create_new.py +++ b/tests/functional/tests_user_create_new.py @@ -19,7 +19,7 @@ def setUp(self): def test_create_new_user(self): - """create new user with valid data""" + """create new user with valid data(positive)""" create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, NewUser.password, NewUser.isUser) @@ -33,21 +33,21 @@ def test_create_new_user(self): self.assertEqual(32, len_of_new_user_token) def test_create_new_with_exist_name(self): - """create new user with already exist name""" + """create new user with already exist name(negative)""" create_new_user = self.application.create_new_user(self.admin_token, DefaultUser.user, NewUser.password, NewUser.isUser) self.assertEqual(200, create_new_user.status_code) - self.assertFalse(create_new_user.json()['content']) + self.assertIn('false', create_new_user.text, "User was created with a name what already exist") # try to login with new user login = self.application.login(DefaultUser.user, NewUser.password) len_of_new_user_token = len(login.json()['content']) self.assertEqual(200, login.status_code) - self.assertNotEqual(32, len_of_new_user_token, "User was created with a name what already exist") + self.assertNotEqual(32, len_of_new_user_token) def test_with_non_admin_token(self): - """create new user with usage of non admin token""" + """create new user with usage of non admin token(negative)""" # login with existed user login = self.application.login(UserToTest.login, UserToTest.password) @@ -56,12 +56,12 @@ def test_with_non_admin_token(self): # create new user with user token create_new_user = self.application.create_new_user(user_token, NewUser.name, NewUser.password, NewUser.isUser) self.assertEqual(200, create_new_user.status_code) - self.assertFalse(create_new_user.json()['content']) + self.assertIn('false', create_new_user.text) # try to login with new user login_new_user = self.application.login(NewUser.name, NewUser.password) self.assertEqual(200, login_new_user.status_code) - self.assertIn("ERROR", login_new_user.text, "User was created with user token") + self.assertIn("ERROR, user not found", login_new_user.text, "User was created with user token") def test_give_invalid_admin_rights(self): """create new user with invalid admin rights""" @@ -74,7 +74,7 @@ def test_give_invalid_admin_rights(self): # try to login with new user login = self.application.login(NewUser.name, NewUser.password) text_of_login_message = str(login.content) - self.assertIn("ERROR", text_of_login_message, "User was created with invalid admin rights") + self.assertIn("ERROR, user not found", text_of_login_message, "User was created with invalid admin rights") @idata(InvalidValues.values) def test_wrong_new_login(self, value): @@ -82,20 +82,21 @@ def test_wrong_new_login(self, value): create_new_user = self.application.create_new_user(self.admin_token, value, NewUser.password, NewUser.isUser) self.assertEqual(200, create_new_user.status_code) - self.assertTrue(create_new_user.json()['content']) + self.assertIn('false', create_new_user.text, "User with '{}' login was created".format(value)) # try to login with new user login = self.application.login(value, NewUser.password) - self.assertIn("ERROR, user not found", login.text, "User {} was found".format(value)) + self.assertEqual(200, create_new_user.status_code) + self.assertIn("ERROR, user not found", login.text) @idata(InvalidValues.values) def test_wrong_new_pass(self, value): """create new user with only spaces on login""" create_new_user = self.application.create_new_user(self.admin_token, NewUser.name, value, NewUser.isUser) self.assertEqual(200, create_new_user.status_code) - self.assertFalse(create_new_user.json()['content']) + self.assertIn('false', create_new_user.text, "User with '{}' pass was found".format(value)) # try to login with new user login = self.application.login(NewUser.name, value) self.assertEqual(200, login.status_code) - self.assertIn("ERROR, user not found", login.text, "User {} was found".format(value)) + self.assertIn("ERROR, user not found", login.text) diff --git a/tests/functional/tests_user_remove.py b/tests/functional/tests_user_remove.py index febe844..1195fc9 100644 --- a/tests/functional/tests_user_remove.py +++ b/tests/functional/tests_user_remove.py @@ -29,7 +29,7 @@ def test_remove_user(self): self.assertNotIn(UserToTest.login, get_user_list.text, "User was not deleted") def test_delete_without_name(self): - """Try to delete user without name, only with token""" + """Try to delete user without name, only with token(negative)""" name_empty = InvalidValues.values[2] removed_user = self.application.delete_user(self.admin_token, name_empty) @@ -37,7 +37,7 @@ def test_delete_without_name(self): self.assertIn("false", removed_user.text, "Error. User was deleted without name") def test_delete_without_token(self): - """Try to delete user without token, only with name""" + """Try to delete user without token, only with name(negative)""" token_empty = InvalidValues.values[2] removed_user = self.application.delete_user(token_empty, UserToTest.login) @@ -45,19 +45,19 @@ def test_delete_without_token(self): self.assertIn("false", removed_user.text, "Error, we got deletion without token") def test_admin_delete_himself(self): - """Delete admin""" + """Delete admin(negative)""" removed_user = self.application.delete_user(self.admin_token, DefaultUser.user) get_answer = str(removed_user.json()['content']) self.assertEqual(200, removed_user.status_code) - self.assertIn('True', get_answer) + self.assertNotIn('True', get_answer) # search user in user list get_user_list = self.application.get_all_users(self.admin_token) self.assertIn(DefaultUser.user, get_user_list.text, "Error, admin has deleted himself") def test_user_delete_himself(self): - """User delete himself with user token""" + """User delete himself with user token(negative)""" login = self.application.login(UserToTest.login, UserToTest.password) token = login.json()['content'] @@ -77,7 +77,7 @@ def test_user_delete_himself(self): self.assertIn(UserToTest.login, get_user_list.text, "Error, user delete himself with user token") def test_user_token_delete_admin(self): - """Login with user and use user token to delete admin""" + """Login with user and use user token to delete admin(negative)""" # login with user and get user token login = self.application.login(UserToTest.login, UserToTest.password) @@ -98,7 +98,7 @@ def test_user_token_delete_admin(self): self.assertIn(DefaultUser.user, get_user_list.text, "Error, user delete admin with user token") def test_admin_token_not_right(self): - """Use wrong token""" + """Use wrong token(negative)""" invalid_token = DefaultToken.token removed_user = self.application.delete_user(invalid_token, UserToTest.login) @@ -113,10 +113,11 @@ def test_admin_token_not_right(self): self.assertIn(UserToTest.login, get_user_list.text, "Error, user was deleted with wrong token") def test_user_not_exist_deletion(self): - """Delete not exist user""" + """Delete not exist user(negative)""" removed_user = self.application.delete_user(self.admin_token, "testuser") self.assertEqual(200, removed_user.status_code) + self.assertIn('false', removed_user.text) # search test user in user list get_user_list = self.application.get_all_users(self.admin_token)