pk/atst
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update tests for Flask

Browse Source
This commit is contained in:
dandds
2018-08-02 13:49:39 -04:00
parent 5987748898
commit 45b47c41bf
32 changed files with 468 additions and 482 deletions
Download Patch File Download Diff File Expand all files Collapse all files

76
tests/conftest.py
View File

@@ -1,44 +1,72 @@
import os
import pytest
import alembic.config
import alembic.command
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker, scoped_session
from atst.app import make_app, make_deps, make_config
from atst.database import make_db
from atst.app import make_app, make_config
from tests.mocks import MockApiClient
from atst.sessions import DictSessions
from atst.models import Base
from atst.database import db as _db
@pytest.fixture
def app(db):
TEST_DEPS = {
"authnid_client": MockApiClient("authnid"),
"sessions": DictSessions(),
"db_session": db
}
@pytest.fixture(scope='session')
def app(request):
config = make_config()
deps = make_deps(config)
deps.update(TEST_DEPS)
return make_app(config, deps)
_app = make_app(config)
ctx = _app.app_context()
ctx.push()
def teardown():
ctx.pop()
return _app
@pytest.fixture(scope='function')
def db():
def apply_migrations():
"""Applies all alembic migrations."""
alembic_config = os.path.join(os.path.dirname(__file__), "../", "alembic.ini")
config = alembic.config.Config(alembic_config)
app_config = make_config()
config.set_main_option('sqlalchemy.url', app_config["DATABASE_URI"])
alembic.command.upgrade(config, 'head')
# Override db with a new SQLAlchemy session so that we can rollback
# each test's transaction.
# Inspiration: https://docs.sqlalchemy.org/en/latest/orm/session_transaction.html#session-external-transaction
config = make_config()
database = make_db(config)
connection = database.get_bind().connect()
@pytest.fixture(scope='session')
def db(app, request):
def teardown():
_db.drop_all()
_db.app = app
apply_migrations()
yield _db
_db.drop_all()
@pytest.fixture(scope='function', autouse=True)
def session(db, request):
"""Creates a new database session for a test."""
connection = db.engine.connect()
transaction = connection.begin()
db = scoped_session(sessionmaker(bind=connection))
yield db
options = dict(bind=connection, binds={})
session = db.create_scoped_session(options=options)
db.session = session
yield session
db.close()
transaction.rollback()
connection.close()
session.remove()
class DummyForm(dict):

26
tests/domain/test_pe_numbers.py
View File

@@ -6,36 +6,32 @@ from atst.domain.pe_numbers import PENumbers
from tests.factories import PENumberFactory
@pytest.fixture()
def pe_numbers(db):
return PENumbers(db)
@pytest.fixture(scope="function")
def new_pe_number(db):
def new_pe_number(session):
def make_pe_number(**kwargs):
pen = PENumberFactory.create(**kwargs)
db.add(pen)
db.commit()
session.add(pen)
session.commit()
return pen
return make_pe_number
def test_can_get_pe_number(pe_numbers, new_pe_number):
def test_can_get_pe_number(new_pe_number):
new_pen = new_pe_number(number="0701367F", description="Combat Support - Offensive")
pen = pe_numbers.get(new_pen.number)
pen = PENumbers.get(new_pen.number)
assert pen.number == new_pen.number
def test_nonexistent_pe_number_raises(pe_numbers):
def test_nonexistent_pe_number_raises():
with pytest.raises(NotFoundError):
pe_numbers.get("some fake number")
PENumbers.get("some fake number")
def test_create_many(pe_numbers):
def test_create_many():
pen_list = [['123456', 'Land Speeder'], ['7891011', 'Lightsaber']]
pe_numbers.create_many(pen_list)
PENumbers.create_many(pen_list)
assert pe_numbers.get(pen_list[0][0])
assert pe_numbers.get(pen_list[1][0])
assert PENumbers.get(pen_list[0][0])
assert PENumbers.get(pen_list[1][0])

19
tests/domain/test_requests.py
View File

@@ -8,14 +8,14 @@ from tests.factories import RequestFactory
@pytest.fixture()
def requests(db):
return Requests(db)
def requests(session):
return Requests()
@pytest.fixture(scope="function")
def new_request(db):
def new_request(session):
created_request = RequestFactory.create()
db.add(created_request)
db.commit()
session.add(created_request)
session.commit()
return created_request
@@ -31,25 +31,22 @@ def test_nonexistent_request_raises(requests):
requests.get(uuid4())
@pytest.mark.gen_test
def test_auto_approve_less_than_1m(requests, new_request):
new_request.body = {"details_of_use": {"dollar_value": 999999}}
request = yield requests.submit(new_request)
request = requests.submit(new_request)
assert request.status == 'approved'
@pytest.mark.gen_test
def test_dont_auto_approve_if_dollar_value_is_1m_or_above(requests, new_request):
new_request.body = {"details_of_use": {"dollar_value": 1000000}}
request = yield requests.submit(new_request)
request = requests.submit(new_request)
assert request.status == 'submitted'
@pytest.mark.gen_test
def test_dont_auto_approve_if_no_dollar_value_specified(requests, new_request):
new_request.body = {"details_of_use": {}}
request = yield requests.submit(new_request)
request = requests.submit(new_request)
assert request.status == 'submitted'

4
tests/domain/test_roles.py
View File

@@ -4,8 +4,8 @@ from atst.domain.exceptions import NotFoundError
@pytest.fixture()
def roles_repo(db):
return Roles(db)
def roles_repo(session):
return Roles(session)
def test_get_all_roles(roles_repo):

10
tests/domain/test_task_orders.py
View File

@@ -7,15 +7,15 @@ from tests.factories import TaskOrderFactory
@pytest.fixture()
def task_orders(db):
return TaskOrders(db)
def task_orders(session):
return TaskOrders(session)
@pytest.fixture(scope="function")
def new_task_order(db):
def new_task_order(session):
def make_task_order(**kwargs):
to = TaskOrderFactory.create(**kwargs)
db.add(to)
db.commit()
session.add(to)
session.commit()
return to

4
tests/domain/test_users.py
View File

@@ -6,8 +6,8 @@ from atst.domain.exceptions import NotFoundError, AlreadyExistsError
@pytest.fixture()
def users_repo(db):
return Users(db)
def users_repo(session):
return Users(session)
@pytest.fixture(scope="function")

8
tests/domain/test_workspace_users.py
View File

@@ -6,13 +6,13 @@ from atst.domain.users import Users
@pytest.fixture()
def users_repo(db):
return Users(db)
def users_repo(session):
return Users(session)
@pytest.fixture()
def workspace_users_repo(db):
return WorkspaceUsers(db)
def workspace_users_repo(session):
return WorkspaceUsers(session)
def test_can_create_new_workspace_user(users_repo, workspace_users_repo):

89
tests/handlers/test_financial_verification.py
View File

@@ -1,89 +0,0 @@
import re
import pytest
import tornado
import urllib
from tests.mocks import MOCK_REQUEST, MOCK_USER
from tests.factories import PENumberFactory
class TestPENumberInForm:
required_data = {
"pe_id": "123",
"task_order_id": "1234567899C0001",
"fname_co": "Contracting",
"lname_co": "Officer",
"email_co": "jane@mail.mil",
"office_co": "WHS",
"fname_cor": "Officer",
"lname_cor": "Representative",
"email_cor": "jane@mail.mil",
"office_cor": "WHS",
"funding_type": "RDTE",
"funding_type_other": "other",
"clin_0001": "50,000",
"clin_0003": "13,000",
"clin_1001": "30,000",
"clin_1003": "7,000",
"clin_2001": "30,000",
"clin_2003": "7,000",
}
def _set_monkeypatches(self, monkeypatch):
monkeypatch.setattr(
"atst.handlers.request_financial_verification.RequestFinancialVerification.get_current_user", lambda s: MOCK_USER
)
monkeypatch.setattr(
"atst.handlers.request_financial_verification.RequestFinancialVerification.check_xsrf_cookie", lambda s: True
)
monkeypatch.setattr("atst.forms.request.RequestForm.validate", lambda s: True)
monkeypatch.setattr("atst.domain.requests.Requests.get", lambda s, i: MOCK_REQUEST)
@tornado.gen.coroutine
def submit_data(self, http_client, base_url, data):
response = yield http_client.fetch(
base_url + "/requests/verify/{}".format(MOCK_REQUEST.id),
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body=urllib.parse.urlencode(data),
follow_redirects=False,
raise_error=False,
)
return response
@pytest.mark.gen_test
def test_submit_request_form_with_invalid_pe_id(self, monkeypatch, http_client, base_url):
self._set_monkeypatches(monkeypatch)
response = yield self.submit_data(http_client, base_url, self.required_data)
assert "We couldn\'t find that PE number" in response.body.decode()
assert response.code == 200
assert "/requests/verify" in response.effective_url
@pytest.mark.gen_test
def test_submit_request_form_with_unchanged_pe_id(self, monkeypatch, http_client, base_url):
self._set_monkeypatches(monkeypatch)
data = dict(self.required_data)
data['pe_id'] = MOCK_REQUEST.body['financial_verification']['pe_id']
response = yield self.submit_data(http_client, base_url, data)
assert response.code == 302
assert response.headers.get("Location") == "/requests/financial_verification_submitted"
@pytest.mark.gen_test
def test_submit_request_form_with_new_valid_pe_id(self, db, monkeypatch, http_client, base_url):
self._set_monkeypatches(monkeypatch)
pe = PENumberFactory.create(number="8675309U", description="sample PE number")
db.add(pe)
db.commit()
data = dict(self.required_data)
data['pe_id'] = pe.number
response = yield self.submit_data(http_client, base_url, data)
assert response.code == 302
assert response.headers.get("Location") == "/requests/financial_verification_submitted"

54
tests/handlers/test_request_new.py
View File

@@ -1,54 +0,0 @@
import re
import pytest
import tornado
import urllib
from tests.mocks import MOCK_USER
from tests.factories import RequestFactory
ERROR_CLASS = "alert--error"
MOCK_REQUEST = RequestFactory.create(
creator=MOCK_USER["id"],
body={
"financial_verification": {
"pe_id": "0203752A",
},
}
)
@pytest.mark.gen_test
def test_submit_invalid_request_form(monkeypatch, http_client, base_url):
monkeypatch.setattr(
"atst.handlers.request_new.RequestNew.get_current_user", lambda s: MOCK_USER
)
monkeypatch.setattr(
"atst.handlers.request_new.RequestNew.check_xsrf_cookie", lambda s: True
)
# this just needs to send a known invalid form value
response = yield http_client.fetch(
base_url + "/requests/new",
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body="total_ram=5",
)
assert response.effective_url == base_url + "/requests/new"
assert re.search(ERROR_CLASS, response.body.decode())
@pytest.mark.gen_test
def test_submit_valid_request_form(monkeypatch, http_client, base_url):
monkeypatch.setattr(
"atst.handlers.request_new.RequestNew.get_current_user", lambda s: MOCK_USER
)
monkeypatch.setattr(
"atst.handlers.request_new.RequestNew.check_xsrf_cookie", lambda s: True
)
monkeypatch.setattr("atst.forms.request.RequestForm.validate", lambda s: True)
# this just needs to send a known invalid form value
response = yield http_client.fetch(
base_url + "/requests/new",
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body="meaning=42",
)
assert "/requests/new/2" in response.effective_url

57
tests/handlers/test_request_submit.py
View File

@@ -1,57 +0,0 @@
import pytest
import tornado
from tests.mocks import MOCK_USER
from tests.factories import RequestFactory
@tornado.gen.coroutine
def _mock_func(*args, **kwargs):
return RequestFactory.create()
@pytest.mark.gen_test
def test_submit_reviewed_request(monkeypatch, http_client, base_url):
monkeypatch.setattr(
"atst.handlers.request_submit.RequestsSubmit.get_current_user",
lambda s: MOCK_USER,
)
monkeypatch.setattr(
"atst.handlers.request_submit.RequestsSubmit.check_xsrf_cookie", lambda s: True
)
monkeypatch.setattr("atst.domain.requests.Requests.get", _mock_func)
monkeypatch.setattr("atst.domain.requests.Requests.submit", _mock_func)
monkeypatch.setattr("atst.models.request.Request.status", "pending")
# this just needs to send a known invalid form value
response = yield http_client.fetch(
base_url + "/requests/submit/1",
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body="",
raise_error=False,
follow_redirects=False,
)
assert response.headers["Location"] == "/requests"
@pytest.mark.gen_test
def test_submit_autoapproved_reviewed_request(monkeypatch, http_client, base_url):
monkeypatch.setattr(
"atst.handlers.request_submit.RequestsSubmit.get_current_user",
lambda s: MOCK_USER,
)
monkeypatch.setattr(
"atst.handlers.request_submit.RequestsSubmit.check_xsrf_cookie", lambda s: True
)
monkeypatch.setattr("atst.domain.requests.Requests.get", _mock_func)
monkeypatch.setattr("atst.domain.requests.Requests.submit", _mock_func)
monkeypatch.setattr("atst.models.request.Request.status", "approved")
# this just needs to send a known invalid form value
response = yield http_client.fetch(
base_url + "/requests/submit/1",
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body="",
raise_error=False,
follow_redirects=False,
)
assert response.headers["Location"] == "/requests?modal=True"

76
tests/routes/test_financial_verification.py Normal file
View File

@@ -0,0 +1,76 @@
import re
import pytest
import tornado
import urllib
from tests.mocks import MOCK_REQUEST, MOCK_USER
from tests.factories import PENumberFactory
class TestPENumberInForm:
required_data = {
"pe_id": "123",
"task_order_id": "1234567899C0001",
"fname_co": "Contracting",
"lname_co": "Officer",
"email_co": "jane@mail.mil",
"office_co": "WHS",
"fname_cor": "Officer",
"lname_cor": "Representative",
"email_cor": "jane@mail.mil",
"office_cor": "WHS",
"funding_type": "RDTE",
"funding_type_other": "other",
"clin_0001": "50,000",
"clin_0003": "13,000",
"clin_1001": "30,000",
"clin_1003": "7,000",
"clin_2001": "30,000",
"clin_2003": "7,000",
}
def _set_monkeypatches(self, monkeypatch):
monkeypatch.setattr("atst.forms.financial.FinancialForm.validate", lambda s: True)
monkeypatch.setattr("atst.domain.requests.Requests.get", lambda i: MOCK_REQUEST)
def submit_data(self, client, data):
response = client.post(
"/requests/verify/{}".format(MOCK_REQUEST.id),
headers={"Content-Type": "application/x-www-form-urlencoded"},
data=urllib.parse.urlencode(data),
follow_redirects=False,
)
return response
def test_submit_request_form_with_invalid_pe_id(self, monkeypatch, client):
self._set_monkeypatches(monkeypatch)
response = self.submit_data(client, self.required_data)
assert "We couldn\'t find that PE number" in response.data.decode()
assert response.status_code == 200
def test_submit_request_form_with_unchanged_pe_id(self, monkeypatch, client):
self._set_monkeypatches(monkeypatch)
data = dict(self.required_data)
data['pe_id'] = MOCK_REQUEST.body['financial_verification']['pe_id']
response = self.submit_data(client, data)
assert response.status_code == 302
assert "/requests/financial_verification_submitted" in response.headers.get("Location")
def test_submit_request_form_with_new_valid_pe_id(self, session, monkeypatch, client):
self._set_monkeypatches(monkeypatch)
pe = PENumberFactory.create(number="8675309U", description="sample PE number")
session.add(pe)
session.commit()
data = dict(self.required_data)
data['pe_id'] = pe.number
response = self.submit_data(client, data)
assert response.status_code == 302
assert "/requests/financial_verification_submitted" in response.headers.get("Location")

35
tests/routes/test_request_new.py Normal file
View File

@@ -0,0 +1,35 @@
import re
import pytest
import urllib
from tests.mocks import MOCK_USER
from tests.factories import RequestFactory
ERROR_CLASS = "alert--error"
MOCK_REQUEST = RequestFactory.create(
creator=MOCK_USER["id"],
body={
"financial_verification": {
"pe_id": "0203752A",
},
}
)
def test_submit_invalid_request_form(monkeypatch, client):
response = client.post(
"/requests/new/1",
headers={"Content-Type": "application/x-www-form-urlencoded"},
data="total_ram=5",
)
assert re.search(ERROR_CLASS, response.data.decode())
def test_submit_valid_request_form(monkeypatch, client):
monkeypatch.setattr("atst.forms.request.RequestForm.validate", lambda s: True)
response = client.post(
"/requests/new/1",
headers={"Content-Type": "application/x-www-form-urlencoded"},
data="meaning=42",
)
assert "/requests/new/2" in response.headers.get("Location")

37
tests/routes/test_request_submit.py Normal file
View File

@@ -0,0 +1,37 @@
import pytest
import tornado
from tests.mocks import MOCK_USER
from tests.factories import RequestFactory
def _mock_func(*args, **kwargs):
return RequestFactory.create()
def test_submit_reviewed_request(monkeypatch, client):
monkeypatch.setattr("atst.domain.requests.Requests.get", _mock_func)
monkeypatch.setattr("atst.domain.requests.Requests.submit", _mock_func)
monkeypatch.setattr("atst.models.request.Request.status", "pending")
# this just needs to send a known invalid form value
response = client.post(
"/requests/submit/1",
headers={"Content-Type": "application/x-www-form-urlencoded"},
data="",
follow_redirects=False,
)
assert "/requests" in response.headers["Location"]
assert "modal" not in response.headers["Location"]
def test_submit_autoapproved_reviewed_request(monkeypatch, client):
monkeypatch.setattr("atst.domain.requests.Requests.get", _mock_func)
monkeypatch.setattr("atst.domain.requests.Requests.submit", _mock_func)
monkeypatch.setattr("atst.models.request.Request.status", "approved")
# this just needs to send a known invalid form value
response = client.post(
"/requests/submit/1",
headers={"Content-Type": "application/x-www-form-urlencoded"},
data="",
follow_redirects=False,
)
assert "/requests?modal=True" in response.headers["Location"]

10
tests/test_api_client.py
View File

@@ -1,10 +0,0 @@
import pytest
from atst.api_client import ApiClient
@pytest.mark.gen_test
def test_api_client(http_client, base_url):
client = ApiClient(base_url)
response = yield client.get("")
assert response.code == 200

137
tests/test_auth.py
View File

@@ -1,81 +1,78 @@
import re
import pytest
import tornado.web
import tornado.gen
MOCK_USER = {"id": "438567dd-25fa-4d83-a8cc-8aa8366cb24a"}
@tornado.gen.coroutine
def _fetch_user_info(c, t):
return MOCK_USER
@pytest.mark.gen_test
def test_redirects_when_not_logged_in(http_client, base_url):
response = yield http_client.fetch(
base_url + "/home", raise_error=False, follow_redirects=False
)
location = response.headers["Location"]
assert response.code == 302
assert response.error
assert re.match("/\??", location)
@pytest.mark.skip
def test_redirects_when_not_logged_in():
pass
# response = yield http_client.fetch(
# base_url + "/home", raise_error=False, follow_redirects=False
# )
# location = response.headers["Location"]
# assert response.code == 302
# assert response.error
# assert re.match("/\??", location)
@pytest.mark.gen_test
def test_redirects_when_session_does_not_exist(monkeypatch, http_client, base_url):
monkeypatch.setattr("atst.handlers.main.Main.get_secure_cookie", lambda s,c: 'stale cookie!')
response = yield http_client.fetch(
base_url + "/home", raise_error=False, follow_redirects=False
)
location = response.headers["Location"]
cookie = response.headers._dict.get('Set-Cookie')
# should clear session cookie
assert 'atat=""' in cookie
assert response.code == 302
assert response.error
assert re.match("/\??", location)
# @pytest.mark.skip
# def test_redirects_when_session_does_not_exist():
# monkeypatch.setattr("atst.handlers.main.Main.get_secure_cookie", lambda s,c: 'stale cookie!')
# response = yield http_client.fetch(
# base_url + "/home", raise_error=False, follow_redirects=False
# )
# location = response.headers["Location"]
# cookie = response.headers._dict.get('Set-Cookie')
# # should clear session cookie
# assert 'atat=""' in cookie
# assert response.code == 302
# assert response.error
# assert re.match("/\??", location)
@pytest.mark.gen_test
def test_login_with_valid_bearer_token(app, monkeypatch, http_client, base_url):
monkeypatch.setattr("atst.handlers.login_redirect.LoginRedirect._fetch_user_info", _fetch_user_info)
response = yield http_client.fetch(
base_url + "/login-redirect?bearer-token=abc-123",
follow_redirects=False,
raise_error=False,
)
assert response.headers["Set-Cookie"].startswith("atat")
assert response.headers["Location"] == "/home"
assert response.code == 302
@pytest.mark.gen_test
def test_login_via_dev_endpoint(app, http_client, base_url):
response = yield http_client.fetch(
base_url + "/login-dev", raise_error=False, follow_redirects=False
)
assert response.headers["Set-Cookie"].startswith("atat")
assert response.code == 302
assert response.headers["Location"] == "/home"
@pytest.mark.gen_test
@pytest.mark.skip(reason="need to work out auth error user paths")
def test_login_with_invalid_bearer_token(http_client, base_url):
_response = yield http_client.fetch(
base_url + "/home",
raise_error=False,
headers={"Cookie": "bearer-token=anything"},
)
@pytest.mark.gen_test
def test_valid_login_creates_session(app, monkeypatch, http_client, base_url):
monkeypatch.setattr("atst.handlers.login_redirect.LoginRedirect._fetch_user_info", _fetch_user_info)
assert len(app.sessions.sessions) == 0
yield http_client.fetch(
base_url + "/login-redirect?bearer-token=abc-123",
follow_redirects=False,
raise_error=False,
)
assert len(app.sessions.sessions) == 1
session = list(app.sessions.sessions.values())[0]
assert "atat_permissions" in session["user"]
assert isinstance(session["user"]["atat_permissions"], list)
# @pytest.mark.skip
# def test_login_with_valid_bearer_token():
# monkeypatch.setattr("atst.handlers.login_redirect.LoginRedirect._fetch_user_info", _fetch_user_info)
# response = client.fetch(
# base_url + "/login-redirect?bearer-token=abc-123",
# follow_redirects=False,
# raise_error=False,
# )
# assert response.headers["Set-Cookie"].startswith("atat")
# assert response.headers["Location"] == "/home"
# assert response.code == 302
#
#
# @pytest.mark.skip
# def test_login_via_dev_endpoint():
# response = yield http_client.fetch(
# base_url + "/login-dev", raise_error=False, follow_redirects=False
# )
# assert response.headers["Set-Cookie"].startswith("atat")
# assert response.code == 302
# assert response.headers["Location"] == "/home"
#
#
# @pytest.mark.skip
# def test_login_with_invalid_bearer_token():
# _response = yield http_client.fetch(
# base_url + "/home",
# raise_error=False,
# headers={"Cookie": "bearer-token=anything"},
# )
#
# @pytest.mark.skip
# def test_valid_login_creates_session():
# monkeypatch.setattr("atst.handlers.login_redirect.LoginRedirect._fetch_user_info", _fetch_user_info)
# assert len(app.sessions.sessions) == 0
# yield http_client.fetch(
# base_url + "/login-redirect?bearer-token=abc-123",
# follow_redirects=False,
# raise_error=False,
# )
# assert len(app.sessions.sessions) == 1
# session = list(app.sessions.sessions.values())[0]
# assert "atat_permissions" in session["user"]
# assert isinstance(session["user"]["atat_permissions"], list)

10
tests/test_basic.py
View File

@@ -1,7 +1,3 @@
import pytest
@pytest.mark.gen_test
def test_hello_world(http_client, base_url):
response = yield http_client.fetch(base_url)
assert response.code == 200
def test_hello_world(client):
response = client.get("/")
assert response.status_code == 200

32
tests/test_integration.py
View File

@@ -1,13 +1,14 @@
import pytest
import tornado
from tests.mocks import MOCK_USER
from atst.handlers.request_new import JEDIRequestFlow
from atst.routes.requests.jedi_request_flow import JEDIRequestFlow
SCREENS = JEDIRequestFlow(None, None, 3).screens
@pytest.fixture
def screens(app):
return JEDIRequestFlow(3).screens
@pytest.mark.gen_test
def test_stepthrough_request_form(monkeypatch, http_client, base_url):
@pytest.mark.skip()
def test_stepthrough_request_form(monkeypatch, screens, client):
monkeypatch.setattr(
"atst.handlers.request_new.RequestNew.get_current_user", lambda s: MOCK_USER
)
@@ -18,29 +19,28 @@ def test_stepthrough_request_form(monkeypatch, http_client, base_url):
"atst.handlers.request_new.JEDIRequestFlow.validate", lambda s: True
)
@tornado.gen.coroutine
def take_a_step(inc, req=None):
req_url = base_url + "/requests/new/{}".format(inc)
req_url = "/requests/new/{}".format(inc)
if req:
req_url += "/" + req
response = yield http_client.fetch(
response = client.post(
req_url,
method="POST",
headers={"Content-Type": "application/x-www-form-urlencoded"},
body="meaning=42",
data="meaning=42",
)
return response
# GET the initial form
response = yield http_client.fetch(base_url + "/requests/new", method="GET")
assert SCREENS[0]["title"] in response.body.decode()
response = client.get("/requests/new")
assert screens[0]["title"] in response.data.decode()
# POST to each of the form pages up until review and submit
req_id = None
for i in range(1, len(SCREENS)):
resp = yield take_a_step(i, req=req_id)
for i in range(1, len(screens)):
resp = take_a_step(i, req=req_id)
__import__('ipdb').set_trace()
req_id = resp.effective_url.split("/")[-1]
screen_title = SCREENS[i]["title"].replace("&", "&")
screen_title = screens[i]["title"].replace("&", "&")
assert "/requests/new/{}/{}".format(i + 1, req_id) in resp.effective_url
assert screen_title in resp.body.decode()
assert screen_title in resp.data.decode()

11
tests/test_routes.py
View File

@@ -1,18 +1,19 @@
import pytest
@pytest.mark.gen_test
def test_routes(http_client, base_url):
def test_routes(client):
for path in (
"/",
"/home",
"/workspaces",
"/requests",
"/requests/new",
"/requests/new/1",
"/requests/new/2",
"/users",
"/reports",
"/calculator",
):
response = yield http_client.fetch(base_url + path)
assert response.code == 200
response = client.get(path)
if response.status_code == 404:
__import__('ipdb').set_trace()
assert response.status_code == 200