async def test_synse_led_write_valid_6(mock_validate_device_type, mock_write,
no_pretty_json):
"""Test writing LED state with a valid state specified."""
r = utils.make_request('/synse/led?color=ffffff&state=on')
result = await led_route(r, 'rack-1', 'vec', '123456')
expected = [{
'context': {
'action': 'state',
'data': b'on'
},
'transaction': 'rack-1-vec-123456'
}, {
'context': {
'action': 'color',
'data': b'ffffff'
},
'transaction': 'rack-1-vec-123456'
}]
expected_json = ujson.dumps(expected)
assert isinstance(result, HTTPResponse)
assert result.body == expected_json.encode('ascii')
assert result.status == 200
async def test_synse_scan_route_bad_param(mock_scan, no_pretty_json):
"""Test scanning, passing an unsupported query param."""
r = utils.make_request('/synse/scan?unsupported=true')
with pytest.raises(errors.InvalidArgumentsError):
await scan_route(r)
async def test_synse_power_route_bad_param(mock_validate_device_type, mock_write, no_pretty_json):
"""Test setting power, passing an unsupported query param."""
r = utils.make_request('/synse/power?unsupported=true')
with pytest.raises(errors.InvalidArgumentsError):
await power_route(r, 'rack-1', 'vec', '123456')
def test_federation_client_unsafe_ip(self, resolver):
self.sydent.run()
request, channel = make_request(
self.sydent.reactor,
"POST",
"/_matrix/identity/v2/account/register",
{
"access_token": "foo",
"expires_in": 300,
"matrix_server_name": "example.com",
"token_type": "Bearer",
},
)
resolver.return_value = [
Server(
host=self.unsafe_domain,
port=443,
priority=1,
weight=1,
expires=100,
)
]
request.render(self.sydent.servlets.registerServlet)
self.assertNot(self.reactor.tcpClients)
self.assertEqual(channel.code, 500)
async def test_synse_config_route(mock_plugins, no_pretty_json):
"""Test successfully getting the plugins."""
result = await plugins_route(utils.make_request('/synse/plugins'))
assert isinstance(result, HTTPResponse)
assert result.body == b'[]'
assert result.status == 200
async def test_synse_info_route_no_optional(mock_info, no_pretty_json):
"""Test successfully getting the info without optional params specified."""
result = await info_route(utils.make_request('/synse/info'), 'rack1')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"r":"rack1","b":null,"d":null}'
assert result.status == 200
async def test_synse_config_route(mock_config, no_pretty_json):
"""Test successfully getting the config."""
result = await config_route(utils.make_request('/synse/config'))
assert isinstance(result, HTTPResponse)
assert result.body == b'{"test":"config"}'
assert result.status == 200
async def test_synse_info_route(mock_info, no_pretty_json):
"""Test successfully getting the info."""
result = await info_route(utils.make_request('/synse/info'), 'rack1',
'board1', 'device1')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"r":"rack1","b":"board1","d":"device1"}'
assert result.status == 200
async def test_synse_read_route(mock_read, no_pretty_json):
"""Test a successful read."""
result = await read_route(utils.make_request('/synse/read'), 'rack-1',
'vec', '123456')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"value":1}'
assert result.status == 200
async def test_synse_write_route_invalid_json(mock_write, no_pretty_json):
"""Write when 'raw' and 'action' are not in the given request body."""
data = {'key1': 'color', 'key2': [b'00ff55']}
r = utils.make_request('/synse/write', data)
with pytest.raises(SynseError):
await write_route(r, 'rack-1', 'vec', '123456')
async def test_synse_fan_route_bad_params(mock_validate_device_type,
mock_write, no_pretty_json):
"""Test setting fan, passing both 'speed' and 'speed_percent' params,
which is not supported."""
r = utils.make_request('/synse/fan?speed=100&speed_percent=50')
with pytest.raises(errors.InvalidArgumentsError):
await fan_route(r, 'rack-1', 'vec', '123456')
async def test_synse_power_read(mock_validate_device_type, mock_read, no_pretty_json):
"""Test a successful read."""
r = utils.make_request('/synse/power')
result = await power_route(r, 'rack-1', 'vec', '123456')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"value":1}'
assert result.status == 200
async def test_synse_scan_route_with_rack_and_board(mock_scan, no_pretty_json):
"""Test performing a scan with a rack and board specified."""
r = utils.make_request('/synse/scan')
result = await scan_route(r, 'rack-1', 'vec')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"r":"rack-1","b":"vec","forced":false}'
assert result.status == 200
async def test_synse_led_write_invalid_6(mock_validate_device_type, mock_write, no_pretty_json):
"""Test writing LED state with an invalid state specified."""
r = utils.make_request('/synse/led?color=-FF')
try:
await led_route(r, 'rack-1', 'vec', '123456')
except errors.SynseError as e:
assert e.error_id == errors.INVALID_ARGUMENTS
assert '-FF' in e.args[0]
async def test_synse_scan_route(mock_scan, no_pretty_json):
"""Test a successful scan."""
r = utils.make_request('/synse/scan')
result = await scan_route(r)
assert isinstance(result, HTTPResponse)
assert result.body == b'{"r":null,"b":null,"forced":false}'
assert result.status == 200
async def test_synse_scan_route_forced(mock_scan, no_pretty_json):
"""Test forcing a rescan successfully."""
r = utils.make_request('/synse/scan?force=true')
result = await scan_route(r)
assert isinstance(result, HTTPResponse)
assert result.body == b'{"r":null,"b":null,"forced":true}'
assert result.status == 200
async def test_validate_no_query_params():
"""Test validating that an incoming request has no query params, when there
are no query params.
"""
@validate.no_query_params()
async def test_fn(request, *args, **kwargs):
"""Dummy function for testing the decorator."""
return request
await test_fn(utils.make_request('/synse/endpoint'))
async def test_synse_write_route_bad_json(mock_write, no_pretty_json):
"""Write when invalid JSON is posted."""
data = '{{/.'
r = utils.make_request('/synse/write')
r.body = data
with pytest.raises(InvalidJsonError):
await write_route(r, 'rack-1', 'vec', '123456')
async def test_synse_led_write_valid_5(mock_validate_device_type, mock_write, no_pretty_json):
"""Test writing LED state with a valid state specified."""
r = utils.make_request('/synse/led?color=ffffff')
result = await led_route(r, 'rack-1', 'vec', '123456')
assert isinstance(result, HTTPResponse)
assert result.body == b'[{"context":{"action":"color","raw":["ffffff"]},"transaction":"rack-1-vec-123456"}]'
assert result.status == 200
async def test_synse_power_write_invalid(mock_validate_device_type, mock_write, no_pretty_json):
"""Test writing power state with an invalid state specified."""
r = utils.make_request('/synse/power?state=test')
try:
await power_route(r, 'rack-1', 'vec', '123456')
except errors.SynseError as e:
assert e.error_id == errors.INVALID_ARGUMENTS
assert 'test' in e.args[0]
async def test_synse_power_write_valid_2(mock_validate_device_type, mock_write, no_pretty_json):
"""Test writing power state with a valid state specified."""
r = utils.make_request('/synse/power?state=off')
result = await power_route(r, 'rack-1', 'vec', '123456')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"data":{"action":"state","raw":"off"}}'
assert result.status == 200
async def test_synse_scan_route_forced_2(mock_scan, no_pretty_json):
"""Test forcing a rescan, but using an unrecognized value."""
r = utils.make_request('/synse/scan?force=yes')
result = await scan_route(r)
assert isinstance(result, HTTPResponse)
assert result.body == b'{"r":null,"b":null,"forced":false}'
assert result.status == 200
def test_incoming_replication(self):
"""Impersonate a peer that sends a replication push to Sydent, then checks that it
accepts the payload and saves it correctly.
"""
self.sydent.run()
# Configure the Sydent to impersonate. We need to use "fake.server" as the
# server's name because that's the name the recipient Sydent has for it. On top
# of that, the replication servlet expects a TLS certificate in the request so it
# can extract a common name and figure out which peer sent it from its common
# name. The common name of the certificate we use for tests is fake.server.
config = {
"general": {
"server.name": "fake.server"
},
"crypto": {
"ed25519.signingkey":
"ed25519 0 b29eXMMAYCFvFEtq9mLI42aivMtcg4Hl0wK89a+Vb6c"
},
}
fake_sender_sydent = make_sydent(config)
signer = Signer(fake_sender_sydent)
# Sign the associations with the Sydent to impersonate so the recipient Sydent
# can verify the signatures on them.
signed_assocs = {}
for assoc_id, assoc in enumerate(self.assocs):
signed_assoc = signer.signedThreePidAssociation(assoc)
signed_assocs[assoc_id] = signed_assoc
# Send the replication push.
body = json.dumps({"sgAssocs": signed_assocs})
request, channel = make_request(self.sydent.reactor, "POST",
"/_matrix/identity/replicate/v1/push",
body)
request.render(self.sydent.servlets.replicationPush)
self.assertEqual(channel.code, 200)
# Check that the recipient Sydent has correctly saved the associations in the
# push.
cur = self.sydent.db.cursor()
res = cur.execute(
"SELECT originId, sgAssoc FROM global_threepid_associations")
res_assocs = {}
for row in res.fetchall():
originId = row[0]
signed_assoc = json.loads(row[1])
res_assocs[originId] = signed_assoc
for assoc_id, signed_assoc in signed_assocs.items():
self.assertDictEqual(signed_assoc, res_assocs[assoc_id])
def test_request_code_via_url_query_params(self) -> None:
self.sydent.run()
url = ("/_matrix/identity/api/v1/validate/msisdn/requestToken?"
"phone_number=447700900750"
"&country=GB"
"&client_secret=oursecret"
"&send_attempt=0")
request, channel = make_request(self.sydent.reactor, "POST", url)
sendSMS_mock = self._render_request(request)
sendSMS_mock.assert_called_once()
self.assertEqual(channel.code, 200)
async def test_synse_fan_write_valid(mock_validate_device_type, mock_write,
no_pretty_json):
"""Test writing fan speed (rpm) with a valid target specified."""
r = utils.make_request('/synse/fan?speed=500')
result = await fan_route(r, 'rack-1', 'vec', '123456')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"data":{"action":"speed","raw":"500"}}'
assert result.status == 200
async def test_synse_lock_write_valid_1(mock_validate_device_type, mock_write,
no_pretty_json):
"""Test writing lock state with a valid state specified."""
r = utils.make_request('/synse/lock?action=unlock')
result = await lock_route(r, 'rack-1', 'vec', '123456')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"data":{"action":"unlock"}}'
assert result.status == 200
async def test_synse_boot_target_write_valid_1(mock_validate_device_type,
mock_write, no_pretty_json):
"""Test writing boot target with a valid target specified."""
r = utils.make_request('/synse/boot_target?target=pxe')
result = await boot_target_route(r, 'rack-1', 'vec', '123456')
assert isinstance(result, HTTPResponse)
assert result.body == b'{"data":{"action":"target","raw":"pxe"}}'
assert result.status == 200
async def test_synse_boot_target_write_invalid(mock_validate_device_type,
mock_write, no_pretty_json):
"""Test writing boot target with an invalid target specified."""
r = utils.make_request('/synse/boot_target?target=test')
try:
await boot_target_route(r, 'rack-1', 'vec', '123456')
except errors.SynseError as e:
assert e.error_id == errors.INVALID_ARGUMENTS
assert 'test' in e.args[0]
async def test_validate_no_query_params2():
"""Test validating that an incoming request has no query params, when there
are query params. In this case, we expect an error.
"""
@validate.no_query_params()
async def test_fn(request, *args, **kwargs):
"""Dummy function for testing the decorator."""
return request
with pytest.raises(errors.InvalidArgumentsError):
await test_fn(utils.make_request('/synse/endpoint?test=param'))
async def test_synse_test_route():
"""Test successfully hitting the test route."""
result = await synse_test_route(utils.make_request('/synse/test'))
assert isinstance(result, HTTPResponse)
assert result.status == 200
body = ujson.loads(result.body)
assert 'status' in body
assert 'timestamp' in body
assert body['status'] == 'ok'
