def test_channels_not_deleted_when_new_spectrum_inquiry_request_arrives(
self, number_of_channels):
# Given
unregistered = self.cbsd_states[CbsdStates.UNREGISTERED.value]
cbsd = DBCbsd(id=1,
cbsd_id="foo1",
state_id=unregistered,
desired_state_id=unregistered)
self._create_channels_for_cbsd(cbsd, number_of_channels)
cbsd_channels_count_pre_request = len(cbsd.channels)
self.assertEqual(number_of_channels, cbsd_channels_count_pre_request)
request_map = {"spectrumInquiryRequest": [{"cbsdId": "foo1"}]}
# When
self.rc_service._store_requests_from_map_in_db(request_map)
self.session.commit()
cbsd_channels_count_post_request = len(cbsd.channels)
# Then
self.assertEqual(number_of_channels, cbsd_channels_count_post_request)
def test_grant_attempts_after_response(self, code, message_type, expected):
cbsd = DBCbsd(
cbsd_id=CBSD_ID,
user_id=USER_ID,
fcc_id=FCC_ID,
cbsd_serial_number=CBSD_SERIAL_NR,
grant_attempts=INITIAL_GRANT_ATTEMPTS,
state=self._get_db_enum(DBCbsdState, CbsdStates.REGISTERED.value),
desired_state=self._get_db_enum(DBCbsdState, CbsdStates.REGISTERED.value),
)
request = DBRequest(
type=self._get_db_enum(DBRequestType, message_type),
cbsd=cbsd,
payload={'cbsdId': CBSD_ID},
)
response = self._prepare_response_from_db_requests(
db_requests=[request],
response_code=code,
)
self.session.add(request)
self.session.commit()
self._process_response(
request_type_name=message_type,
response=response,
db_requests=[request],
)
self.assertEqual(expected, cbsd.grant_attempts)
def test_unset_frequency(self, orig_avail_freqs, low_freq, high_freq, expected_avail_freq):
# Given
cbsd = DBCbsd(
cbsd_id="some_cbsd_id",
fcc_id="some_fcc_id",
cbsd_serial_number="some_serial_number",
user_id="some_user_id",
state_id=1,
desired_state_id=1,
available_frequencies=orig_avail_freqs,
)
grant = DBGrant(
cbsd=cbsd,
state_id=1,
grant_id="some_grant_id",
low_frequency=low_freq,
high_frequency=high_freq,
max_eirp=15,
)
self.session.add_all([cbsd, grant])
self.session.commit()
# When
unset_frequency(grant)
cbsd = self.session.query(DBCbsd).filter(DBCbsd.id == cbsd.id).scalar()
# Then
self.assertEqual(expected_avail_freq, cbsd.available_frequencies)
def _change_cbsd_state(cbsd: DBCbsd, session: Session, new_state: str) -> None:
if not cbsd:
return
state = session.query(DBCbsdState).filter(
DBCbsdState.name == new_state, ).scalar()
print(f"Changing {cbsd=} {cbsd.state=} to {new_state=}")
cbsd.state = state
def setUp(self):
super().setUp()
cbsd_state = DBCbsdState(name='some_cbsd_state')
cbsd = DBCbsd(
state=cbsd_state,
fcc_id=SOME_FCC_ID,
cbsd_serial_number=SOME_SERIAL_NUMBER,
network_id=SOME_NETWORK_ID,
)
self.session.add(cbsd)
self.session.commit()
def setUp(self):
super().setUp()
cbsd_state = DBCbsdState(name='some_cbsd_state')
cbsd = DBCbsd(
state=cbsd_state,
fcc_id=SOME_FCC_ID,
cbsd_serial_number=SOME_SERIAL_NUMBER,
network_id=SOME_NETWORK_ID,
)
req_type = DBRequestType(name=HEARTBEAT_REQUEST)
self.session.add_all([cbsd, req_type])
self.session.commit()
def _update_fields_from_request(self, cbsd: DBCbsd, request: CBSDRequest):
cbsd.fcc_id = request.fcc_id
cbsd.user_id = request.user_id
cbsd.min_power = request.min_power
cbsd.max_power = request.max_power
cbsd.antenna_gain = request.antenna_gain
cbsd.number_of_ports = request.number_of_ports
def _get_or_create_cbsd(self, session: Session,
request: CBSDRequest) -> DBCbsd:
cbsd = session.query(DBCbsd).filter(
DBCbsd.cbsd_serial_number == request.serial_number, ).first()
if cbsd:
self._update_fields_from_request(cbsd, request)
return cbsd
unregistered_state = session.query(DBCbsdState). \
filter(DBCbsdState.name == CbsdStates.UNREGISTERED.value).first()
cbsd = DBCbsd(
cbsd_serial_number=request.serial_number,
state=unregistered_state,
)
self._update_fields_from_request(cbsd, request)
session.add(cbsd)
return cbsd
def _create_cbsd(self, session: Session, request_payload: Dict,
cbsd_id: Optional[str]):
cbsd_state_id = self.cbsd_states_map[CbsdStates.UNREGISTERED.value]
user_id = request_payload.get("userId", None)
fcc_id = request_payload.get("fccId", None)
cbsd_serial_number = request_payload.get("cbsdSerialNumber", None)
cbsd = DBCbsd(
cbsd_id=cbsd_id,
state_id=cbsd_state_id,
desired_state_id=cbsd_state_id,
user_id=user_id,
fcc_id=fcc_id,
cbsd_serial_number=cbsd_serial_number,
)
session.add(cbsd)
logging.info(f"New CBSD {cbsd=} created.")
return cbsd
def _create_cbsd(self, session: Session, request_payload: Dict, cbsd_id: Optional[str]):
cbsd_state = session.query(DBCbsdState).filter(
DBCbsdState.name == CbsdStates.UNREGISTERED.value,
).scalar()
user_id = request_payload.get("userId", None)
fcc_id = request_payload.get("fccId", None)
cbsd_serial_number = request_payload.get("cbsdSerialNumber", None)
cbsd = DBCbsd(
cbsd_id=cbsd_id,
state=cbsd_state,
user_id=user_id,
fcc_id=fcc_id,
cbsd_serial_number=cbsd_serial_number,
)
session.add(cbsd)
logging.info(f"New CBSD {cbsd=} created.")
return cbsd
def _generate_cbsd_from_request_json(self, request_payload: Dict, cbsd_state: DBCbsdState):
cbsd_id = request_payload.get(CBSD_ID)
fcc_id = request_payload.get(FCC_ID)
user_id = request_payload.get(USER_ID)
serial_number = request_payload.get(CBSD_SERIAL_NR)
cbsd = DBCbsd(
cbsd_id=cbsd_id,
fcc_id=fcc_id,
cbsd_serial_number=serial_number,
user_id=user_id,
state=cbsd_state,
)
self.session.add(cbsd)
self.session.commit()
return cbsd
def _prepare_two_pending_and_one_processed_request(self):
test_state = DBCbsdState(name="test_state")
cbsds = []
for i in range(1, 4):
cbsds.append(
DBCbsd(
id=int(i),
cbsd_id=f"foo{i}",
state=test_state,
user_id="test_user",
fcc_id=f"test_fcc_id{i}",
cbsd_serial_number=f"test_serial_nr{i}",
), )
req_type = DBRequestType(name="someRequest")
pending_status = DBRequestState(name="pending")
processed_status = DBRequestState(name="processed")
req1 = DBRequest(
cbsd=cbsds[0],
type=req_type,
state=pending_status,
payload={
"some": "payload1",
},
)
req2 = DBRequest(
cbsd=cbsds[1],
type=req_type,
state=pending_status,
payload={
"some": "payload2",
},
)
req3 = DBRequest(
cbsd=cbsds[2],
type=req_type,
state=processed_status,
payload={
"some": "payload3",
},
)
self.session.add_all([req1, req2, req3])
self.session.commit()
def test_get_request_response(self, req_id, db_response_payload,
grpc_expected_response_payload):
# Given
cbsd = DBCbsd(id=1, cbsd_id="foo1", state=self.unregistered_state)
db_request = DBRequest(id=1, cbsd_id=cbsd.id)
db_response = DBResponse(
id=1,
request_id=1,
response_code=0,
payload=db_response_payload,
)
self.session.add_all([cbsd, db_request, db_response])
self.session.commit()
# When
grpc_response_payload = json.loads(
self.rc_service._get_request_response(req_id).payload, )
# Then
self.assertEqual(grpc_expected_response_payload, grpc_response_payload)
def _change_cbsd_state(cbsd: DBCbsd, session: Session, new_state: str) -> None:
state = session.query(DBCbsdState).filter(
DBCbsdState.name == new_state, ).scalar()
cbsd.state = state
def __init__(self):
self.cbsd = DBCbsd()
def _build_cbsd(self, serial_number, **kwargs) -> DBCbsd:
return DBCbsd(
cbsd_serial_number=serial_number,
state_id=self.cbsd_states[CbsdStates.UNREGISTERED.value],
)
def _set_desired_state_to_registered(self, session: Session,
cbsd: DBCbsd) -> None:
registered_state = session.query(DBCbsdState). \
filter(DBCbsdState.name == CbsdStates.REGISTERED.value).first()
cbsd.desired_state = registered_state
