def test_dp_log_created_from_grpc_request(self, with_cbsd, serial_num,
fcc_id, network_id):
# Given
cbsd = None
if with_cbsd:
cbsd = self.session.query(DBCbsd).first()
message = CBSDRequest(
user_id='some_user_id',
fcc_id=fcc_id,
serial_number=serial_num,
min_power=2,
max_power=3,
antenna_gain=4,
number_of_ports=5,
)
# When
actual_log = make_dp_log(method_name=CBSD_REGISTER,
message=message,
cbsd=cbsd)
# Then
expected_log = DPLog(
event_timestamp=SOME_DATE,
cbsd_serial_number=serial_num,
fcc_id=fcc_id,
log_from=CBSD,
log_message=str(message),
log_name='CBSDRegisterRequest',
log_to=DP,
network_id=network_id,
response_code=None,
)
self.assertEqual(expected_log, actual_log)
def test_dp_log_created_from_db_response(self, with_cbsd, serial_num,
fcc_id, network_id):
# Given
req_type = self.session.query(DBRequestType).first()
cbsd = None
if with_cbsd:
cbsd = self.session.query(DBCbsd).first()
request = DBRequest(type=req_type,
cbsd=cbsd,
payload='some_request_message')
resp_payload = {"response": {"responseCode": "0"}}
response = DBResponse(request=request,
response_code=200,
payload=resp_payload)
# When
actual_log = make_dp_log(response)
# Then
expected_log = DPLog(
cbsd_serial_number=serial_num,
fcc_id=fcc_id,
log_from=SAS,
log_message="{'response': {'responseCode': '0'}}",
log_name='heartbeatResponse',
log_to=DP,
network_id=network_id,
response_code="0",
)
self.assertEqual(expected_log, actual_log)
def _log_result(self, message_type: str, result: CBSDStateResult,
cbsd: DBCbsd, serial_number: str):
try:
log = make_dp_log(result, message_type, cbsd, serial_number)
self.fluentd_client.send_dp_log(log)
except (FluentdClientException, TypeError) as err:
logging.error(f"Failed to log {message_type} result. {err}")
def _log_request(self, message_type: str, request: CBSDRequest,
cbsd: DBCbsd):
try:
log = make_dp_log(request, message_type, cbsd)
self.fluentd_client.send_dp_log(log)
except (FluentdClientException, TypeError) as err:
logging.error(f"Failed to log {message_type} request. {err}")
def test_dp_log_created_from_db_request(self, with_cbsd, serial_num,
fcc_id, network_id):
# Given
req_type = self.session.query(DBRequestType).first()
cbsd = None
if with_cbsd:
cbsd = self.session.query(DBCbsd).first()
request = DBRequest(type=req_type, cbsd=cbsd, payload=SOME_MESSAGE)
# When
actual_log = make_dp_log(request)
# Then
expected_log = DPLog(
event_timestamp=SOME_TIMESTAMP,
cbsd_serial_number=serial_num,
fcc_id=fcc_id,
log_from=DP,
log_message=SOME_MESSAGE,
log_name=HEARTBEAT_REQUEST,
log_to=SAS,
network_id=network_id,
response_code=None,
)
self.assertEqual(expected_log, actual_log)
def _log_requests_map(requests_map: dict, fluentd_client: FluentdClient):
requests_type = next(iter(requests_map))
for request in requests_map[requests_type]:
try:
log = make_dp_log(request)
fluentd_client.send_dp_log(log)
except (FluentdClientException, TypeError) as err:
logging.error(f"Failed to log {requests_type} request. {err}")
def test_dp_log_created_from_grpc_response(self, with_cbsd, fcc_id,
network_id):
# Given
cbsd = None
if with_cbsd:
cbsd = self.session.query(DBCbsd).first()
channels = [
LteChannel(
low_frequency_hz=1,
high_frequency_hz=2,
max_eirp_dbm_mhz=3,
),
LteChannel(
low_frequency_hz=4,
high_frequency_hz=5,
max_eirp_dbm_mhz=6,
),
]
message = CBSDStateResult(
channels=channels,
radio_enabled=True,
carrier_aggregation_enabled=True,
)
# When
actual_log = make_dp_log(
method_name=CBSD_REGISTER,
message=message,
cbsd=cbsd,
serial_number=SOME_SERIAL_NUMBER,
)
# Then
expected_log = DPLog(
event_timestamp=SOME_DATE,
cbsd_serial_number=SOME_SERIAL_NUMBER,
fcc_id=fcc_id,
log_from=DP,
log_message=str(message),
log_name='CBSDRegisterResponse',
log_to=CBSD,
network_id=network_id,
response_code=None,
)
self.assertEqual(expected_log, actual_log)
def test_make_dp_log_returns_type_error_for_unknown_message_type(self):
with self.assertRaises(TypeError):
make_dp_log(IncorrectDPLog())
def _log_response(self, response_type: str, db_response: DBResponse):
try:
log = make_dp_log(db_response)
self.fluentd_client.send_dp_log(log)
except (FluentdClientException, TypeError) as err:
logging.error(f"Failed to log {response_type} response. {err}")
