def test_environ_builder_headers_content_type():
b = EnvironBuilder(headers={"Content-Type": "text/plain"})
env = b.get_environ()
assert env["CONTENT_TYPE"] == "text/plain"
b = EnvironBuilder(content_type="text/html", headers={"Content-Type": "text/plain"})
env = b.get_environ()
assert env["CONTENT_TYPE"] == "text/html"
def test_apihandler_ws_error(conn):
values = {'format': 'json'}
builder = EnvironBuilder(method='POST', data=values)
handler = WebServiceErrorHandler(connect=provider(conn))
resp = handler.handle(Request(builder.get_environ()))
assert_equals('application/json; charset=UTF-8', resp.content_type)
expected = {
"status": "error",
"error": {
"message": "invalid API key",
"code": 4,
}
}
assert_json_equals(expected, resp.data)
assert_equals('400 BAD REQUEST', resp.status)
handler = InternalErrorHandler(connect=provider(conn))
resp = handler.handle(Request(builder.get_environ()))
assert_equals('application/json; charset=UTF-8', resp.content_type)
expected = {
"status": "error",
"error": {
"message": "internal error",
"code": 5,
}
}
assert_json_equals(expected, resp.data)
assert_equals('500 INTERNAL SERVER ERROR', resp.status)
def test_environ_builder_headers_content_type(self):
b = EnvironBuilder(headers={'Content-Type': 'text/plain'})
env = b.get_environ()
self.assert_equal(env['CONTENT_TYPE'], 'text/plain')
b = EnvironBuilder(content_type='text/html',
headers={'Content-Type': 'text/plain'})
env = b.get_environ()
self.assert_equal(env['CONTENT_TYPE'], 'text/html')
def test_environ_builder_headers_content_type():
b = EnvironBuilder(headers={'Content-Type': 'text/plain'})
env = b.get_environ()
assert env['CONTENT_TYPE'] == 'text/plain'
b = EnvironBuilder(content_type='text/html',
headers={'Content-Type': 'text/plain'})
env = b.get_environ()
assert env['CONTENT_TYPE'] == 'text/html'
def test_environ_builder_headers():
b = EnvironBuilder(environ_base={"HTTP_USER_AGENT": "Foo/0.1"}, environ_overrides={"wsgi.version": (1, 1)})
b.headers["X-Beat-My-Horse"] = "very well sir"
env = b.get_environ()
strict_eq(env["HTTP_USER_AGENT"], "Foo/0.1")
strict_eq(env["HTTP_X_BEAT_MY_HORSE"], "very well sir")
strict_eq(env["wsgi.version"], (1, 1))
b.headers["User-Agent"] = "Bar/1.0"
env = b.get_environ()
strict_eq(env["HTTP_USER_AGENT"], "Bar/1.0")
def test_environ_builder_headers(self):
b = EnvironBuilder(environ_base={'HTTP_USER_AGENT': 'Foo/0.1'},
environ_overrides={'wsgi.version': (1, 1)})
b.headers['X-Beat-My-Horse'] = 'very well sir'
env = b.get_environ()
self.assert_strict_equal(env['HTTP_USER_AGENT'], 'Foo/0.1')
self.assert_strict_equal(env['HTTP_X_BEAT_MY_HORSE'], 'very well sir')
self.assert_strict_equal(env['wsgi.version'], (1, 1))
b.headers['User-Agent'] = 'Bar/1.0'
env = b.get_environ()
self.assert_strict_equal(env['HTTP_USER_AGENT'], 'Bar/1.0')
def test_environ_builder_headers(self):
b = EnvironBuilder(environ_base={'HTTP_USER_AGENT': 'Foo/0.1'},
environ_overrides={'wsgi.version': (1, 1)})
b.headers['X-Suck-My-Dick'] = 'very well sir'
env = b.get_environ()
assert env['HTTP_USER_AGENT'] == 'Foo/0.1'
assert env['HTTP_X_SUCK_MY_DICK'] == 'very well sir'
assert env['wsgi.version'] == (1, 1)
b.headers['User-Agent'] = 'Bar/1.0'
env = b.get_environ()
assert env['HTTP_USER_AGENT'] == 'Bar/1.0'
def test_same_submission(self, mock_validate_email):
"""
Tests that the same form is not sent twice.
"""
builder = EnvironBuilder(method='POST',
data={'name': 'Valid Guy',
'email': '*****@*****.**',
'last_name': '',
'token': conf.TOKEN,
'redirect': 'http://www.example.com'})
env = builder.get_environ()
# Mock sendmail function so it doesn't send an actual email
smtplib.SMTP.sendmail = Mock('smtplib.SMTP.sendmail')
mock_validate_email.return_value = True
# Create apps
app = handler.create_app()
# Will cause a duplicate with the last call because
# first app.name = 'Valid Guy' = last app.name
req = Request(env)
app.on_form_page(req)
self.assertEquals(app.error, None)
# Update name so not a duplicate
builder.form['name'] = 'Another Guy'
env = builder.get_environ()
req = Request(env)
app.on_form_page(req)
self.assertEquals(app.error, None)
# Update name so not a duplicate
builder.form['name'] = 'A Third Guy'
env = builder.get_environ()
req = Request(env)
app.on_form_page(req)
self.assertEquals(app.error, None)
# Duplicate with first app because
# first app.name = 'Valid Guy' = this app.name
builder.form['name'] = 'Valid Guy'
env = builder.get_environ()
req = Request(env)
app.on_form_page(req)
self.assertEquals(app.error, 'Duplicate Request')
def test_loading_file(self):
"""Test that it loads image from disk."""
test_string = 'hello'
self.hass.wsgi = mock.MagicMock()
with mock.patch('os.path.isfile', mock.Mock(return_value=True)), \
mock.patch('os.access', mock.Mock(return_value=True)):
assert setup_component(self.hass, 'camera', {
'camera': {
'name': 'config_test',
'platform': 'local_file',
'file_path': 'mock.file',
}})
image_view = self.hass.wsgi.mock_calls[0][1][0]
m_open = mock.mock_open(read_data=test_string)
with mock.patch(
'homeassistant.components.camera.local_file.open',
m_open, create=True
):
builder = EnvironBuilder(method='GET')
Request = request_class() # pylint: disable=invalid-name
request = Request(builder.get_environ())
request.authenticated = True
resp = image_view.get(request, 'camera.config_test')
assert resp.status_code == 200, resp.response
assert resp.response[0].decode('utf-8') == test_string
def test_send_email_default(self, mock_validate_email):
"""
Tests that the form is sent to the correct default address when
the 'send_to' field is set to an empty string.
Returns true if the form has been sent to [email protected]
Errors out if unsuccessful
"""
builder = EnvironBuilder(method='POST',
data={'name': 'Valid Guy',
'email': '*****@*****.**',
'send_to': '',
'last_name': '',
'token': conf.TOKEN,
'redirect': 'http://www.example.com'})
env = builder.get_environ()
req = Request(env)
# Construct message for assertion
msg = handler.create_msg(req)
msg_send = MIMEText(str(msg))
msg_subj = handler.set_mail_subject(msg)
msg_send['Subject'] = msg_subj
msg_send['To'] = conf.EMAIL['default']
# Mock sendmail function
smtplib.SMTP.sendmail = Mock('smtplib.SMTP.sendmail')
# Call send_email and assert sendmail was correctly called
handler.send_email(msg, msg_subj, send_to_email='default')
smtplib.SMTP.sendmail.assert_called_with(conf.FROM,
conf.EMAIL['default'],
msg_send.as_string())
def test_send_reverse_xhr_request(self, mock):
content = 'xhr content'
builder = EnvironBuilder(headers=self.headers,
path='/fake_app_id/xhr/api/v1/collector',
method='POST')
env = builder.get_environ()
request = Request(env)
context = PxContext(request, self.config)
headers = {
'host': self.config.collector_host,
px_constants.FIRST_PARTY_HEADER: '1',
px_constants.ENFORCER_TRUE_IP_HEADER: context.ip,
px_constants.FIRST_PARTY_FORWARDED_FOR: '127.0.0.1'
}
mock.post(
url=
'https://collector-pxfake_app_id.perimeterx.net/api/v1/collector',
text=content,
request_headers=headers,
status_code=200,
reason='OK')
px_proxy = PxProxy(self.config)
status, headers, body = px_proxy.send_reverse_xhr_request(
config=self.config, ctx=context, body=content)
self.assertEqual(content, body)
def test_03_no_detail_on_success(self):
builder = EnvironBuilder(method='POST',
data={'serial': "HOTP123435"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
# The response contains the token type SPASS
res = {"jsonrpc": "2.0",
"result": {"status": True,
"value": True},
"version": "privacyIDEA test",
"id": 1,
"detail": {"message": "matching 1 tokens",
"serial": "HOTP123456",
"type": "hotp"}}
resp = Response(json.dumps(res))
# Set a policy, that does not allow the detail on success
set_policy(name="pol2",
scope=SCOPE.AUTHZ,
action="no_detail_on_success", client="10.0.0.0/8")
g.policy_object = PolicyClass()
new_response = no_detail_on_success(req, resp)
jresult = json.loads(new_response.data)
self.assertTrue("detail" not in jresult, jresult)
delete_policy("pol2")
def test_10_check_external(self):
g.logged_in_user = {"username": "******",
"role": "user"}
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
req = Request(env)
g.policy_object = PolicyClass()
req.all_data = {
"user": "******",
"realm": "home"}
# Check success on no definition
r = check_external(req)
self.assertTrue(r)
# Check success with external function
current_app.config["PI_INIT_CHECK_HOOK"] = \
"privacyidea.api.lib.prepolicy.mock_success"
r = check_external(req)
self.assertTrue(r)
# Check exception with external function
current_app.config["PI_INIT_CHECK_HOOK"] = \
"privacyidea.api.lib.prepolicy.mock_fail"
self.assertRaises(Exception, check_external, req)
def test_03_check_token_upload(self):
g.logged_in_user = {"username": "******",
"role": "admin"}
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
req.all_data = {"filename": "token.xml"}
# Set a policy, that does allow the action
set_policy(name="pol1",
scope=SCOPE.ADMIN,
action="enrollTOTP, enrollHOTP, %s" % ACTION.IMPORT,
client="10.0.0.0/8")
g.policy_object = PolicyClass()
# Try to import tokens
r = check_token_upload(req)
self.assertTrue(r)
# The admin can not upload from another IP address
# An exception is raised
env["REMOTE_ADDR"] = "192.168.0.1"
req = Request(env)
req.all_data = {"filename": "token.xml"}
self.assertRaises(PolicyError,
check_token_upload, req)
# finally delete policy
delete_policy("pol1")
def test_08_check_conditions_serial(self):
uhandler = UserNotificationEventHandler()
# check a serial with regexp
builder = EnvironBuilder(method='POST',
data={'user': "******"},
headers={})
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******", "serial": "OATH123456"}
req.User = User("cornelius", "realm1")
resp = Response()
resp.data = """{"result": {"value": true}}"""
r = uhandler.check_condition({
"g": {},
"handler_def": {
"conditions": {
"serial": "^OATH.*"
}
},
"request": req,
"response": resp
})
# Serial matches the regexp
self.assertEqual(r, True)
def test_06_check_conditions_realm(self):
uhandler = UserNotificationEventHandler()
# check a locked token with maxfail = failcount
builder = EnvironBuilder(method='POST',
data={'user': "******"},
headers={})
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******"}
req.User = User("cornelius", "realm1")
resp = Response()
resp.data = """{"result": {"value": false}}"""
r = uhandler.check_condition({
"g": {},
"handler_def": {
"conditions": {
"realm": "realm2"
}
},
"request": req,
"response": resp
})
# wrong realm
self.assertEqual(r, False)
def test_environ_builder_paths(self):
b = EnvironBuilder(path='/foo', base_url='http://example.com/')
assert b.base_url == 'http://example.com/'
assert b.path == '/foo'
assert b.script_root == ''
assert b.host == 'example.com'
b = EnvironBuilder(path='/foo', base_url='http://example.com/bar')
assert b.base_url == 'http://example.com/bar/'
assert b.path == '/foo'
assert b.script_root == '/bar'
assert b.host == 'example.com'
b.host = 'localhost'
assert b.base_url == 'http://localhost/bar/'
b.base_url = 'http://localhost:8080/'
assert b.host == 'localhost:8080'
assert b.server_name == 'localhost'
assert b.server_port == 8080
b.host = 'foo.invalid'
b.url_scheme = 'https'
b.script_root = '/test'
env = b.get_environ()
assert env['SERVER_NAME'] == 'foo.invalid'
assert env['SERVER_PORT'] == '443'
assert env['SCRIPT_NAME'] == '/test'
assert env['PATH_INFO'] == '/foo'
assert env['HTTP_HOST'] == 'foo.invalid'
assert env['wsgi.url_scheme'] == 'https'
assert b.base_url == 'https://foo.invalid/test/'
def test_request_header_authorization(header, secrets, expected):
builder = EnvironBuilder()
builder.headers.extend(header)
request = NotifyRequest(builder.get_environ())
res = _check_proxy_header_secret(request, secrets, list(header.keys())[0])
assert res == expected
def test_environ_builder_paths():
b = EnvironBuilder(path="/foo", base_url="http://example.com/")
assert b.base_url == "http://example.com/"
assert b.path == "/foo"
assert b.script_root == ""
assert b.host == "example.com"
b = EnvironBuilder(path="/foo", base_url="http://example.com/bar")
assert b.base_url == "http://example.com/bar/"
assert b.path == "/foo"
assert b.script_root == "/bar"
assert b.host == "example.com"
b.host = "localhost"
assert b.base_url == "http://localhost/bar/"
b.base_url = "http://localhost:8080/"
assert b.host == "localhost:8080"
assert b.server_name == "localhost"
assert b.server_port == 8080
b.host = "foo.invalid"
b.url_scheme = "https"
b.script_root = "/test"
env = b.get_environ()
assert env["SERVER_NAME"] == "foo.invalid"
assert env["SERVER_PORT"] == "443"
assert env["SCRIPT_NAME"] == "/test"
assert env["PATH_INFO"] == "/foo"
assert env["HTTP_HOST"] == "foo.invalid"
assert env["wsgi.url_scheme"] == "https"
assert b.base_url == "https://foo.invalid/test/"
def test_envrion_builder_multiple_headers():
h = Headers()
h.add("FOO", "bar")
h.add("FOO", "baz")
b = EnvironBuilder(headers=h)
env = b.get_environ()
assert env["HTTP_FOO"] == "bar, baz"
def test_environ_builder_paths():
b = EnvironBuilder(path="/foo", base_url="http://example.com/")
strict_eq(b.base_url, "http://example.com/")
strict_eq(b.path, "/foo")
strict_eq(b.script_root, "")
strict_eq(b.host, "example.com")
b = EnvironBuilder(path="/foo", base_url="http://example.com/bar")
strict_eq(b.base_url, "http://example.com/bar/")
strict_eq(b.path, "/foo")
strict_eq(b.script_root, "/bar")
strict_eq(b.host, "example.com")
b.host = "localhost"
strict_eq(b.base_url, "http://localhost/bar/")
b.base_url = "http://localhost:8080/"
strict_eq(b.host, "localhost:8080")
strict_eq(b.server_name, "localhost")
strict_eq(b.server_port, 8080)
b.host = "foo.invalid"
b.url_scheme = "https"
b.script_root = "/test"
env = b.get_environ()
strict_eq(env["SERVER_NAME"], "foo.invalid")
strict_eq(env["SERVER_PORT"], "443")
strict_eq(env["SCRIPT_NAME"], "/test")
strict_eq(env["PATH_INFO"], "/foo")
strict_eq(env["HTTP_HOST"], "foo.invalid")
strict_eq(env["wsgi.url_scheme"], "https")
strict_eq(b.base_url, "https://foo.invalid/test/")
def test_submit_handler_with_meta(conn):
values = {'format': 'json', 'client': 'app1key', 'user': '******',
'duration': str(TEST_1_LENGTH), 'fingerprint': TEST_1_FP, 'bitrate': 192,
'mbid': 'b9c05616-1874-4d5d-b30e-6b959c922d28', 'fileformat': 'FLAC',
'track': 'Voodoo People',
'artist': 'The Prodigy',
'album': 'Music For The Jitled People',
'albumartist': 'Prodigy',
'trackno': '2',
'discno': '3',
'year': '2030'
}
builder = EnvironBuilder(method='POST', data=values)
handler = SubmitHandler(connect=provider(conn))
resp = handler.handle(Request(builder.get_environ()))
assert_equals('application/json; charset=UTF-8', resp.content_type)
expected = {"status": "ok"}
assert_json_equals(expected, resp.data)
assert_equals('200 OK', resp.status)
query = tables.submission.select().order_by(tables.submission.c.id.desc()).limit(1)
submission = conn.execute(query).fetchone()
assert_equals('b9c05616-1874-4d5d-b30e-6b959c922d28', submission['mbid'])
assert_equals(1, submission['meta_id'])
row = conn.execute("SELECT * FROM meta WHERE id=1").fetchone()
expected = {
'id': 1,
'track': 'Voodoo People',
'artist': 'The Prodigy',
'album': 'Music For The Jitled People',
'album_artist': 'Prodigy',
'track_no': 2,
'disc_no': 3,
'year': 2030
}
assert_equals(expected, dict(row))
def test_07_sign_response(self):
builder = EnvironBuilder(method='POST',
data={},
headers={})
env = builder.get_environ()
env["REMOTE_ADDR"] = "192.168.0.1"
req = Request(env)
req.values = {"user": "******",
"pass": "******",
"nonce": "12345678"}
res = {"jsonrpc": "2.0",
"result": {"status": True,
"value": True},
"version": "privacyIDEA test",
"id": 1}
resp = Response(json.dumps(res))
from privacyidea.lib.crypto import Sign
g.sign_object = Sign("tests/testdata/private.pem",
"tests/testdata/public.pem")
new_response = sign_response(req, resp)
jresult = json.loads(new_response.data)
self.assertEqual(jresult.get("nonce"), "12345678")
self.assertEqual(jresult.get("signature"), "7220461805369685253863294214862525311437731987121534735993146952136348520396812489782945679627890785973634896605293523175424850299832912878523161817380029213546063467888018205435416020286712762804412024065559270543774578319469096483246637875013247101135063221604113204491121777932147776087110152414627230087278622508771143940031542890514380486863296102037208395371717795767683973979032142677315402422403254992482761563612174177151960004042109847122772813717599078313600692433727690239340230353616318691769042290314664126975201679642739717702497638318611217001361093950139025744740660953017413716736691777322916588328")
def test_loading_file(self):
"""Test that it loads image from disk."""
self.hass.wsgi = mock.MagicMock()
with NamedTemporaryFile() as fp:
fp.write('hello'.encode('utf-8'))
fp.flush()
assert setup_component(
self.hass, 'camera', {
'camera': {
'name': 'config_test',
'platform': 'local_file',
'file_path': fp.name,
}
})
image_view = self.hass.wsgi.mock_calls[0][1][0]
builder = EnvironBuilder(method='GET')
Request = request_class()
request = Request(builder.get_environ())
request.authenticated = True
resp = image_view.get(request, 'camera.config_test')
assert resp.status_code == 200, resp.response
assert resp.response[0].decode('utf-8') == 'hello'
def test_07_set_random_pin(self):
g.logged_in_user = {"username": "******",
"role": "admin"}
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
# Set a policy that defines the tokenlabel
set_policy(name="pol1",
scope=SCOPE.ENROLL,
action="%s=%s" % (ACTION.OTPPINRANDOM, "12"))
set_policy(name="pinhandling",
scope=SCOPE.ENROLL,
action="%s=privacyidea.lib.pinhandling.base.PinHandler" %
ACTION.PINHANDLING)
g.policy_object = PolicyClass()
# request, that matches the policy
req.all_data = {
"user": "******",
"realm": "home"}
init_random_pin(req)
# Check, if the tokenlabel was added
self.assertEqual(len(req.all_data.get("pin")), 12)
# finally delete policy
delete_policy("pol1")
delete_policy("pinhandling")
def test_full_access_to_name_request(test_name, \
name_request_number, temp_request_number, user_email, user_phone, \
header_name_request_number, header_temp_request_number, header_user_email, header_user_phone, \
expected):
"""Assure that this contains the headers required to fully access an NR."""
from namex.utils.auth import full_access_to_name_request
# setup
nr = RequestDAO()
nr.nrNum = name_request_number or temp_request_number
nr.stateCd = State.DRAFT
nr._source = ValidSources.NAMEREQUEST.value
applicant = Applicant()
applicant.phoneNumber = user_phone
applicant.emailAddress = user_email
nr.applicants.append(applicant)
nr.save_to_db()
builder = EnvironBuilder(method='POST',
data={},
headers={
'BCREG_NR': header_name_request_number,
'BCREG_NRL': header_temp_request_number,
'BCREG-User-Email': header_user_email,
'BCREG-User-Phone': header_user_phone
})
env = builder.get_environ()
req = Request(env)
print(req)
assert expected == full_access_to_name_request(req)
def test_14_required_email(self):
g.logged_in_user = {"username": "******",
"role": "admin"}
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
# Set a mangle policy to change the username
# and only use the last 4 characters of the username
set_policy(name="email1",
scope=SCOPE.REGISTER,
action="%s=/.*@mydomain\..*" % ACTION.REQUIREDEMAIL)
g.policy_object = PolicyClass()
# request, that matches the policy
req.all_data = {"email": "*****@*****.**"}
# This emails is allowed
r = required_email(req)
self.assertTrue(r)
# This email is not allowed
req.all_data = {"email": "*****@*****.**"}
# This emails is allowed
self.assertRaises(RegistrationError, required_email, req)
delete_policy("email1")
g.policy_object = PolicyClass()
# Without a policy, this email can register
req.all_data = {"email": "*****@*****.**"}
# This emails is allowed
r = required_email(req)
self.assertTrue(r)
def test_tg_302(self):
client = Client(application)
builder = EnvironBuilder(path="/tg/http://www.espn.com",
headers=[("Prefer", "tg_302")])
env = builder.get_environ()
app_iter, status, headers = client.run_wsgi_app(env)
assert "302" in status
assert headers.get("Link")
assert "accept-datetime" in headers.get("Vary", "")
assert headers.get("Location") is not None
lh = parse_link_header(headers.get("Link"))
assert get_uri_dt_for_rel(lh, ["original"])
assert get_uri_dt_for_rel(lh, ["first"])
f_dt = get_uri_dt_for_rel(lh, ["first"]).get("first")
assert convert_to_datetime(f_dt["datetime"][0]) is not None
assert get_uri_dt_for_rel(lh, ["last"])
l_dt = get_uri_dt_for_rel(lh, ["last"]).get("last")
assert convert_to_datetime(l_dt["datetime"][0]) is not None
assert get_uri_dt_for_rel(lh, ["memento"])
m_dt = get_uri_dt_for_rel(lh, ["memento"]).get("memento")
assert convert_to_datetime(m_dt["datetime"][0]) is not None
def test_callback_view_no_jwt(self):
"""Test that the notification callback view works without JWT."""
hass = MagicMock()
m = mock_open()
with patch(
'homeassistant.components.notify.html5.open', m, create=True
):
hass.config.path.return_value = 'file.conf'
service = html5.get_service(hass, {})
assert service is not None
# assert hass.called
assert len(hass.mock_calls) == 3
view = hass.mock_calls[2][1][0]
builder = EnvironBuilder(method='POST', data=json.dumps({
'type': 'push',
'tag': '3bc28d69-0921-41f1-ac6a-7a627ba0aa72'
}))
Request = request_class()
resp = view.post(Request(builder.get_environ()))
assert resp.status_code == 401, resp.response
def test_sync_1(self, mock_create_labbooks_no_lfs, mock_config_file):
# Setup responses mock for this test
responses.add(responses.GET, 'https://usersrv.gigantum.io/key',
json={'key': 'afaketoken'}, status=200)
im = InventoryManager(mock_create_labbooks_no_lfs[0])
test_user_lb = im.load_labbook('default', 'default', 'labbook1')
test_user_wf = LabbookWorkflow(test_user_lb)
test_user_wf.publish('default')
# Mock the request context so a fake authorization header is present
builder = EnvironBuilder(path='/labbook', method='POST', headers={'Authorization': 'Bearer AJDFHASD'})
env = builder.get_environ()
req = Request(environ=env)
sally_wf = LabbookWorkflow.import_from_remote(test_user_wf.remote, 'sally', config_file=mock_config_file[0])
sally_lb = sally_wf.labbook
FileOperations.makedir(sally_lb, relative_path='code/sally-dir', create_activity_record=True)
sally_wf.sync('sally')
sync_query = """
mutation x {
syncLabbook(input: {
labbookName: "labbook1",
owner: "default"
}) {
jobKey
}
}
"""
r = mock_create_labbooks_no_lfs[2].execute(sync_query, context_value=req)
assert 'errors' not in r
def test_10_api_endpoint(self):
fixed = "ebedeeefegeheiej"
otpkey = "cc17a4d77eaed96e9d14b5c87a02e718"
uid = "000000000000"
otps = ["ebedeeefegeheiejtjtrutblehenfjljrirgdihrfuetljtt",
"ebedeeefegeheiejlekvlrlkrcluvctenlnnjfknrhgtjned",
"ebedeeefegeheiejktudedbktcnbuntrhdueikggtrugckij",
"ebedeeefegeheiejjvjncbnffdrvjcvrbgdfufjgndfetieu",
"ebedeeefegeheiejdruibhvlvktcgfjiruhltketifnitbuk"
]
token = init_token({"type": "yubikey",
"otpkey": otpkey,
"otplen": len(otps[0]),
"yubikey.prefix": fixed,
"serial": "UBAM12345678_1"})
builder = EnvironBuilder(method='GET',
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
g.client_ip = env["REMOTE_ADDR"]
req = Request(env)
nonce = "random nonce"
apiid = "hallo"
apikey = "1YMEbMZijD3DzL21UfKGnOOI13c="
set_privacyidea_config("yubikey.apiid.{0!s}".format(apiid), apikey)
req.all_data = {'id': apiid,
"otp": otps[0],
"nonce": nonce}
text_type, result = YubikeyTokenClass.api_endpoint(req, g)
self.assertEqual(text_type, "plain")
self.assertTrue("status=OK" in result, result)
self.assertTrue("nonce={0!s}".format(nonce) in result, result)
def test_reset_branch_to_remote(self, fixture_working_dir, mock_create_labbooks_no_lfs):
# Mock the request context so a fake authorization header is present
builder = EnvironBuilder(path='/labbook', method='POST', headers={'Authorization': 'Bearer AJDFHASD'})
env = builder.get_environ()
req = Request(environ=env)
im = InventoryManager(mock_create_labbooks_no_lfs[0])
test_user_lb = im.load_labbook('default', 'default', 'labbook1')
wf = LabbookWorkflow(test_user_lb)
wf.publish(username='******')
hash_original = wf.labbook.git.commit_hash
new_file_path = os.path.join(wf.labbook.root_dir, 'input', 'new-file')
with open(new_file_path, 'w') as f: f.write('File data')
wf.labbook.sweep_uncommitted_changes()
hash_before_reset = wf.labbook.git.commit_hash
publish_query = f"""
mutation c {{
resetBranchToRemote(input: {{
labbookName: "labbook1",
owner: "default"
}}) {{
labbook {{
activeBranchName
}}
}}
}}
"""
r = mock_create_labbooks_no_lfs[2].execute(publish_query, context_value=req)
assert 'errors' not in r
assert wf.labbook.git.commit_hash == hash_original
def test_callback_view_no_jwt(self):
"""Test that the notification callback view works without JWT."""
hass = MagicMock()
with tempfile.NamedTemporaryFile() as fp:
hass.config.path.return_value = fp.name
fp.close()
service = html5.get_service(hass, {})
assert service is not None
# assert hass.called
assert len(hass.mock_calls) == 3
view = hass.mock_calls[2][1][0]
builder = EnvironBuilder(method='POST',
data=json.dumps({
'type':
'push',
'tag':
'3bc28d69-0921-41f1-ac6a-7a627ba0aa72'
}))
Request = request_class()
resp = view.post(Request(builder.get_environ()))
assert resp.status_code == 401, resp.response
def test_registering_new_device_view(self):
"""Test that the HTML view works."""
hass = MagicMock()
with tempfile.NamedTemporaryFile() as fp:
hass.config.path.return_value = fp.name
fp.close()
service = html5.get_service(hass, {})
assert service is not None
# assert hass.called
assert len(hass.mock_calls) == 3
view = hass.mock_calls[1][1][0]
assert view.json_path == fp.name
assert view.registrations == {}
builder = EnvironBuilder(method='POST',
data=json.dumps(SUBSCRIPTION_1))
Request = request_class()
resp = view.post(Request(builder.get_environ()))
expected = {
'unnamed device': SUBSCRIPTION_1,
}
assert resp.status_code == 200, resp.response
assert view.registrations == expected
with open(fp.name) as fpp:
assert json.load(fpp) == expected
def test_loading_file(self):
"""Test that it loads image from disk."""
self.hass.wsgi = mock.MagicMock()
with NamedTemporaryFile() as fp:
fp.write('hello'.encode('utf-8'))
fp.flush()
assert setup_component(self.hass, 'camera', {
'camera': {
'name': 'config_test',
'platform': 'local_file',
'file_path': fp.name,
}})
image_view = self.hass.wsgi.mock_calls[0][1][0]
builder = EnvironBuilder(method='GET')
Request = request_class()
request = Request(builder.get_environ())
request.authenticated = True
resp = image_view.get(request, 'camera.config_test')
assert resp.status_code == 200, resp.response
assert resp.response[0].decode('utf-8') == 'hello'
def test_import_remote_labbook(self, remote_labbook_repo,
fixture_working_dir, property_mocks_fixture,
docker_socket_fixture, monkeypatch):
# Mock the request context so a fake authorization header is present
builder = EnvironBuilder(path='/labbook',
method='POST',
headers={'Authorization': 'Bearer AJDFHASD'})
env = builder.get_environ()
req = Request(environ=env)
monkeypatch.setattr(Configuration, 'find_default_config',
lambda x: fixture_working_dir[0])
def mock_dispatch(*args, **kwargs):
return JobKey('rq:job:000-000-000')
monkeypatch.setattr(Dispatcher, 'dispatch_task', mock_dispatch)
query = f"""
mutation importFromRemote {{
importRemoteLabbook(
input: {{
owner: "test",
labbookName: "sample-repo-lb",
remoteUrl: "{remote_labbook_repo}"
}}) {{
jobKey
}}
}}
"""
r = fixture_working_dir[2].execute(query, context_value=req)
assert 'errors' not in r
assert r['data']['importRemoteLabbook'][
'jobKey'] == 'rq:job:000-000-000'
def test_valid(self):
builder = EnvironBuilder(method='POST', data={**valid_payload})
env = builder.get_environ()
req = Request(env)
f = DatacheckSubmissionForm(req.form)
f = set_dynamic_choices(f)
self.assertTrue(f.validate())
def test_publish_basic(self, fixture_working_dir,
mock_create_labbooks_no_lfs):
# Mock the request context so a fake authorization header is present
builder = EnvironBuilder(path='/labbook',
method='POST',
headers={'Authorization': 'Bearer AJDFHASD'})
env = builder.get_environ()
req = Request(environ=env)
im = InventoryManager(mock_create_labbooks_no_lfs[0])
test_user_lb = im.load_labbook('default', 'default', 'labbook1')
publish_query = f"""
mutation c {{
publishLabbook(input: {{
labbookName: "labbook1",
owner: "default"
}}) {{
jobKey
}}
}}
"""
r = mock_create_labbooks_no_lfs[2].execute(publish_query,
context_value=req)
assert 'errors' not in r
def test_submit_handler_foreignid(conn):
values = {'format': 'json', 'client': 'app1key', 'user': '******',
'duration': str(TEST_1_LENGTH), 'fingerprint': TEST_1_FP, 'bitrate': 192,
'foreignid': 'foo:123', 'fileformat': 'FLAC'}
builder = EnvironBuilder(method='POST', data=values)
handler = SubmitHandler(connect=provider(conn))
resp = handler.handle(Request(builder.get_environ()))
assert_equals('application/json; charset=UTF-8', resp.content_type)
expected = {"status": "ok"}
assert_json_equals(expected, resp.data)
assert_equals('200 OK', resp.status)
query = tables.submission.select().order_by(tables.submission.c.id.desc()).limit(1)
submission = conn.execute(query).fetchone()
assert_equals(None, submission['mbid'])
assert_equals(None, submission['puid'])
assert_equals(1, submission['foreignid_id'])
assert_equals(1, submission['format_id'])
assert_equals(192, submission['bitrate'])
assert_equals(TEST_1_FP_RAW, submission['fingerprint'])
assert_equals(TEST_1_LENGTH, submission['length'])
query = tables.foreignid_vendor.select().order_by(tables.foreignid_vendor.c.id.desc()).limit(1)
row = conn.execute(query).fetchone()
assert_equals(1, row['id'])
assert_equals('foo', row['name'])
query = tables.foreignid.select().order_by(tables.foreignid.c.id.desc()).limit(1)
row = conn.execute(query).fetchone()
assert_equals(1, row['id'])
assert_equals(1, row['vendor_id'])
assert_equals('123', row['name'])
def test_submit_handler(conn):
values = {
'client': 'app1key',
'user': '******',
'length': str(TEST_1_LENGTH),
'fingerprint': TEST_1_FP,
'bitrate': 192,
'mbid': 'b9c05616-1874-4d5d-b30e-6b959c922d28',
'format': 'FLAC'
}
builder = EnvironBuilder(method='POST', data=values)
handler = SubmitHandler.create_from_server(tests.script, conn=conn)
resp = handler.handle(Request(builder.get_environ()))
assert_equals('text/xml; charset=UTF-8', resp.content_type)
expected = "<?xml version='1.0' encoding='UTF-8'?>\n<response><status>ok</status><submissions><submission><status>pending</status><id>1</id></submission></submissions></response>"
assert_equals(expected, resp.data)
assert_equals('200 OK', resp.status)
query = tables.submission.select().order_by(
tables.submission.c.id.desc()).limit(1)
submission = conn.execute(query).fetchone()
assert_equals('b9c05616-1874-4d5d-b30e-6b959c922d28', submission['mbid'])
assert_equals(1, submission['format_id'])
assert_equals(192, submission['bitrate'])
assert_equals(TEST_1_FP_RAW, submission['fingerprint'])
assert_equals(TEST_1_LENGTH, submission['length'])
def test_01a_admin_realms(self):
admin1 = {"username": "******",
"role": "admin",
"realm": "realm1"}
admin2 = {"username": "******",
"role": "admin",
"realm": "realm2"}
set_policy(name="pol",
scope=SCOPE.ADMIN,
action="*", adminrealm="realm1")
g.policy_object = PolicyClass()
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
req.all_data = {}
# admin1 is allowed to do everything
g.logged_in_user = admin1
r = check_base_action(req, action="delete")
self.assertTrue(r)
# admin2 is not allowed.
g.logged_in_user = admin2
self.assertRaises(PolicyError, check_base_action, req, action="delete")
delete_policy("pol")
def test_10_check_conditions_tokentype(self):
uhandler = UserNotificationEventHandler()
# check if tokenrealm is contained
builder = EnvironBuilder(method='POST',
data={'user': "******"},
headers={})
tok = init_token({"serial": "oath1234", "type": "spass"},
user=User("cornelius", "realm1"))
env = builder.get_environ()
req = Request(env)
req.all_data = {"user": "******",
"serial": "oath1234"}
req.User = User("cornelius", "realm1")
resp = Response()
resp.data = """{"result": {"value": true}}"""
r = uhandler.check_condition(
{"g": {},
"handler_def": {"conditions": {"tokentype": "totp,spass,oath,"}},
"request": req,
"response": resp
}
)
# Serial matches the regexp
self.assertEqual(r, True)
def test_06_set_tokenlabel(self):
g.logged_in_user = {"username": "******",
"role": "admin"}
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
# Set a policy that defines the tokenlabel
set_policy(name="pol1",
scope=SCOPE.ENROLL,
action="%s=%s" % (ACTION.TOKENLABEL, "<u>@<r>"))
set_policy(name="pol2",
scope=SCOPE.ENROLL,
action="%s=%s" % (ACTION.TOKENISSUER, "myPI"))
g.policy_object = PolicyClass()
# request, that matches the policy
req.all_data = {
"user": "******",
"realm": "home"}
init_tokenlabel(req)
# Check, if the tokenlabel was added
self.assertEqual(req.all_data.get("tokenlabel"), "<u>@<r>")
# Check, if the tokenissuer was added
self.assertEqual(req.all_data.get("tokenissuer"), "myPI")
# finally delete policy
delete_policy("pol1")
delete_policy("pol2")
def test_publish_basic(self, fixture_working_dir, remote_bare_repo,
mock_create_labbooks_no_lfs):
# Mock the request context so a fake authorization header is present
builder = EnvironBuilder(path='/labbook',
method='POST',
headers={'Authorization': 'Bearer AJDFHASD'})
env = builder.get_environ()
req = Request(environ=env)
test_user_lb = LabBook(mock_create_labbooks_no_lfs[0])
test_user_lb.from_name('default', 'default', 'labbook1')
publish_query = f"""
mutation c {{
publishLabbook(input: {{
labbookName: "labbook1",
owner: "default"
}}) {{
success
}}
}}
"""
r = mock_create_labbooks_no_lfs[2].execute(publish_query,
context_value=req)
assert 'errors' not in r
assert r['data']['publishLabbook']['success'] is True
def test_08_encrypt_pin(self):
g.logged_in_user = {"username": "******",
"role": "admin"}
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
# Set a policy that defines the PIN to be encrypted
set_policy(name="pol1",
scope=SCOPE.ENROLL,
action=ACTION.ENCRYPTPIN)
g.policy_object = PolicyClass()
# request, that matches the policy
req.all_data = {
"user": "******",
"realm": "home"}
encrypt_pin(req)
# Check, if the tokenlabel was added
self.assertEqual(req.all_data.get("encryptpin"), "True")
# finally delete policy
delete_policy("pol1")
def filestorage(self, filename):
data = open(filename)
builder = EnvironBuilder(method='POST',
data={'file': (data, basename(filename))})
env = builder.get_environ()
req = Request(env)
return req.files['file']
def test_13_remote_user(self):
g.logged_in_user = {"username": "******",
"role": "admin"}
builder = EnvironBuilder(method='POST',
data={'serial': "OATH123456"},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
env["REMOTE_USER"] = "******"
req = Request(env)
# A user, for whom the login via REMOTE_USER is allowed.
set_policy(name="ruser",
scope=SCOPE.WEBUI,
action="%s=%s" % (ACTION.REMOTE_USER, REMOTE_USER.ACTIVE))
g.policy_object = PolicyClass()
r = is_remote_user_allowed(req)
self.assertEqual(r, [REMOTE_USER.ACTIVE])
# Login for the REMOTE_USER is not allowed.
# Only allowed for user "super", but REMOTE_USER=admin
set_policy(name="ruser",
scope=SCOPE.WEBUI,
action="%s=%s" % (ACTION.REMOTE_USER, REMOTE_USER.ACTIVE),
user="******")
g.policy_object = PolicyClass()
r = is_remote_user_allowed(req)
self.assertEqual(r, [])
delete_policy("ruser")
def test_environ_builder_paths():
b = EnvironBuilder(path='/foo', base_url='http://example.com/')
strict_eq(b.base_url, 'http://example.com/')
strict_eq(b.path, '/foo')
strict_eq(b.script_root, '')
strict_eq(b.host, 'example.com')
b = EnvironBuilder(path='/foo', base_url='http://example.com/bar')
strict_eq(b.base_url, 'http://example.com/bar/')
strict_eq(b.path, '/foo')
strict_eq(b.script_root, '/bar')
strict_eq(b.host, 'example.com')
b.host = 'localhost'
strict_eq(b.base_url, 'http://localhost/bar/')
b.base_url = 'http://localhost:8080/'
strict_eq(b.host, 'localhost:8080')
strict_eq(b.server_name, 'localhost')
strict_eq(b.server_port, 8080)
b.host = 'foo.invalid'
b.url_scheme = 'https'
b.script_root = '/test'
env = b.get_environ()
strict_eq(env['SERVER_NAME'], 'foo.invalid')
strict_eq(env['SERVER_PORT'], '443')
strict_eq(env['SCRIPT_NAME'], '/test')
strict_eq(env['PATH_INFO'], '/foo')
strict_eq(env['HTTP_HOST'], 'foo.invalid')
strict_eq(env['wsgi.url_scheme'], 'https')
strict_eq(b.base_url, 'https://foo.invalid/test/')
def test_15_reset_password(self):
builder = EnvironBuilder(method='POST',
data={'user': "******",
"realm": self.realm1},
headers={})
env = builder.get_environ()
# Set the remote address so that we can filter for it
env["REMOTE_ADDR"] = "10.0.0.1"
req = Request(env)
# Set a mangle policy to change the username
# and only use the last 4 characters of the username
set_policy(name="recover",
scope=SCOPE.USER,
action="%s" % ACTION.RESYNC)
g.policy_object = PolicyClass()
req.all_data = {"user": "******", "realm": self.realm1}
# There is a user policy without password reset, so an exception is
# raised
self.assertRaises(PolicyError, check_anonymous_user, req,
ACTION.PASSWORDRESET)
# The password reset is allowed
set_policy(name="recover",
scope=SCOPE.USER,
action="%s" % ACTION.PASSWORDRESET)
g.policy_object = PolicyClass()
r = check_anonymous_user(req, ACTION.PASSWORDRESET)
self.assertEqual(r, True)
def test_get_base_uri(self):
path = '/%s/' % self.test_jp2_color_id
builder = EnvironBuilder(path=path)
env = builder.get_environ()
req = Request(env)
base_uri = self.app._get_base_uri(req, self.test_jp2_color_id)
self.assertEqual(base_uri, 'http://localhost/01%2F02%2F0001.jp2')
def open(self, *args, **kwargs):
as_tuple = kwargs.pop("as_tuple", False)
buffered = kwargs.pop("buffered", False)
follow_redirects = kwargs.pop("follow_redirects", False)
if (not kwargs and len(args) == 1
and isinstance(args[0], (werkzeug.test.EnvironBuilder, dict))):
environ = self.environ_base.copy()
if isinstance(args[0], werkzeug.test.EnvironBuilder):
environ.update(args[0].get_environ())
else:
environ.update(args[0])
environ["flask._preserve_context"] = self.preserve_context
else:
kwargs.setdefault(
"environ_overrides",
{})["flask._preserve_context"] = self.preserve_context
kwargs.setdefault("environ_base", self.environ_base)
builder = EnvironBuilder(self.application, *args, **kwargs)
try:
environ = builder.get_environ()
finally:
builder.close()
return Client.open(
self,
environ,
as_tuple=as_tuple,
buffered=buffered,
follow_redirects=follow_redirects,
)
def test_wrong_token_jwt_sso(self, sso):
Config.jwt_secret = "jwt_token"
builder = EnvironBuilder(headers=[("Cookie", "token=cookie")])
request = Request(builder.get_environ())
user = self.valid_token(token="lallabalalla", _request=request)
self.assertEqual(42, user)
sso.assert_called_once_with("cookie", "lallabalalla")
def test_registering_new_device_view(self):
"""Test that the HTML view works."""
hass = MagicMock()
m = mock_open()
with patch(
'homeassistant.components.notify.html5.open', m, create=True
):
hass.config.path.return_value = 'file.conf'
service = html5.get_service(hass, {})
assert service is not None
# assert hass.called
assert len(hass.mock_calls) == 3
view = hass.mock_calls[1][1][0]
assert view.json_path == hass.config.path.return_value
assert view.registrations == {}
builder = EnvironBuilder(method='POST',
data=json.dumps(SUBSCRIPTION_1))
Request = request_class()
resp = view.post(Request(builder.get_environ()))
expected = {
'unnamed device': SUBSCRIPTION_1,
}
assert resp.status_code == 200, resp.response
assert view.registrations == expected
handle = m()
assert json.loads(handle.write.call_args[0][0]) == expected
def test_submit_handler(conn):
values = {
'format': 'json',
'client': 'app1key',
'user': '******',
'duration': str(TEST_1_LENGTH),
'fingerprint': TEST_1_FP,
'bitrate': 192,
'mbid': 'b9c05616-1874-4d5d-b30e-6b959c922d28',
'fileformat': 'FLAC'
}
builder = EnvironBuilder(method='POST', data=values)
handler = SubmitHandler(connect=provider(conn))
resp = handler.handle(Request(builder.get_environ()))
assert_equals('application/json; charset=UTF-8', resp.content_type)
expected = {"status": "ok"}
assert_json_equals(expected, resp.data)
assert_equals('200 OK', resp.status)
query = tables.submission.select().order_by(
tables.submission.c.id.desc()).limit(1)
submission = conn.execute(query).fetchone()
assert_equals('b9c05616-1874-4d5d-b30e-6b959c922d28', submission['mbid'])
assert_equals(1, submission['format_id'])
assert_equals(192, submission['bitrate'])
assert_equals(TEST_1_FP_RAW, submission['fingerprint'])
assert_equals(TEST_1_LENGTH, submission['length'])
def test_environ_builder_paths(self):
b = EnvironBuilder(path='/foo', base_url='http://example.com/')
assert b.base_url == 'http://example.com/'
assert b.path == '/foo'
assert b.script_root == ''
assert b.host == 'example.com'
b = EnvironBuilder(path='/foo', base_url='http://example.com/bar')
assert b.base_url == 'http://example.com/bar/'
assert b.path == '/foo'
assert b.script_root == '/bar'
assert b.host == 'example.com'
b.host = 'localhost'
assert b.base_url == 'http://localhost/bar/'
b.base_url = 'http://localhost:8080/'
assert b.host == 'localhost:8080'
assert b.server_name == 'localhost'
assert b.server_port == 8080
b.host = 'foo.invalid'
b.url_scheme = 'https'
b.script_root = '/test'
env = b.get_environ()
assert env['SERVER_NAME'] == 'foo.invalid'
assert env['SERVER_PORT'] == '443'
assert env['SCRIPT_NAME'] == '/test'
assert env['PATH_INFO'] == '/foo'
assert env['HTTP_HOST'] == 'foo.invalid'
assert env['wsgi.url_scheme'] == 'https'
assert b.base_url == 'https://foo.invalid/test/'
def test_format_message(self):
# Build test environment
builder = EnvironBuilder(method='POST',
data={'name': 'Valid Guy',
'email': '*****@*****.**',
'some_field': ("This is multi line and "
"should not be on the "
"same line as the title"),
'redirect': 'http://www.example.com',
'last_name': '',
'token': conf.TOKEN})
env = builder.get_environ()
req = Request(env)
target_message = ("Contact:\n"
"--------\n"
"NAME: Valid Guy\n"
"EMAIL: [email protected]\n\n"
"Information:\n"
"------------\n"
"Some Field:\n\n"
"This is multi line and should not be on the same "
"line as the title\n\n")
message = handler.create_msg(req)
formatted_message = handler.format_message(message)
self.assertEqual(formatted_message, target_message)
def setUp(self):
self.ctx = app.test_request_context()
self.ctx.push()
init_data()
self.client = app.test_client()
builder = EnvironBuilder(method='POST')
self.post_env = builder.get_environ()
def test_send_reverse_captcha_request(self, mock):
content = 'captcha js content'
builder = EnvironBuilder(
headers=self.headers,
path='/fake_app_id/captcha/captcha.js',
query_string=
'a=c&u=cfe74220-f484-11e8-9b14-d7280325a290&v=0701bb80-f482-11e8-8a31-a37cf9620569&m=0'
)
env = builder.get_environ()
request = Request(env)
context = PxContext(request, self.config)
headers = {
'host': px_constants.CAPTCHA_HOST,
px_constants.FIRST_PARTY_HEADER: '1',
px_constants.ENFORCER_TRUE_IP_HEADER: context.ip,
px_constants.FIRST_PARTY_FORWARDED_FOR: '127.0.0.1'
}
mock.get(
url=
'https://captcha.px-cdn.net/PXfake_app_id/captcha.js?a=c&u=cfe74220-f484-11e8-9b14-d7280325a290&v=0701bb80-f482-11e8-8a31-a37cf9620569&m=0',
text=content,
request_headers=headers,
status_code=200,
reason='OK')
px_proxy = PxProxy(self.config)
status, headers, body = px_proxy.send_reverse_captcha_request(
config=self.config, ctx=context)
self.assertEqual(content, body)
def test_environ_builder_paths(self):
b = EnvironBuilder(path='/foo', base_url='http://example.com/')
self.assert_strict_equal(b.base_url, 'http://example.com/')
self.assert_strict_equal(b.path, '/foo')
self.assert_strict_equal(b.script_root, '')
self.assert_strict_equal(b.host, 'example.com')
b = EnvironBuilder(path='/foo', base_url='http://example.com/bar')
self.assert_strict_equal(b.base_url, 'http://example.com/bar/')
self.assert_strict_equal(b.path, '/foo')
self.assert_strict_equal(b.script_root, '/bar')
self.assert_strict_equal(b.host, 'example.com')
b.host = 'localhost'
self.assert_strict_equal(b.base_url, 'http://localhost/bar/')
b.base_url = 'http://localhost:8080/'
self.assert_strict_equal(b.host, 'localhost:8080')
self.assert_strict_equal(b.server_name, 'localhost')
self.assert_strict_equal(b.server_port, 8080)
b.host = 'foo.invalid'
b.url_scheme = 'https'
b.script_root = '/test'
env = b.get_environ()
self.assert_strict_equal(env['SERVER_NAME'], 'foo.invalid')
self.assert_strict_equal(env['SERVER_PORT'], '443')
self.assert_strict_equal(env['SCRIPT_NAME'], '/test')
self.assert_strict_equal(env['PATH_INFO'], '/foo')
self.assert_strict_equal(env['HTTP_HOST'], 'foo.invalid')
self.assert_strict_equal(env['wsgi.url_scheme'], 'https')
self.assert_strict_equal(b.base_url, 'https://foo.invalid/test/')
def filestorage(filename, content):
data = StringIO(str(content)) if isinstance(content,
basestring) else content
builder = EnvironBuilder(method='POST', data={'file': (data, filename)})
env = builder.get_environ()
req = Request(env)
return req.files['file']
