def test_rrcConnectionSetupProcedureSuccessful(self):
time.sleep(0.1) # Wait for S1 Setup
def rrcComplete(result):
self.result = result
self.result = None
ueIoService = IoService("ue", 9001)
ueIoService.start()
rrcProcedure = RrcConnectionEstablishmentProcedure(
{
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}, (localhost(), 9000), ueIoService, rrcComplete, {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
},
})
rrcProcedure.execute()
time.sleep(2)
self.assertEqual(self.result,
RrcConnectionEstablishmentProcedure.Success)
ueIoService.stop()
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccess, self.hssSuccess = 0, 0
def tearDown(self):
self.hssIoService.stop()
self.mmeIoService.stop()
def __mmeAuthCompleteCallback__(self, result, authContext=None):
self.mmeSuccess += 1
def __hssAuthCompleteCallback__(self, result, imsi):
self.hssSuccess += 1
def test_nAuthInfoRetrievalProcedureSuccess(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccess, n)
self.assertEqual(self.hssSuccess, n)
def test_rrcConnectionSetupProcedureSuccessful(self):
time.sleep(0.1) # Wait for S1 Setup
def rrcComplete(result):
self.result = result
self.result = None
ueIoService = IoService("ue", 9001)
ueIoService.start()
rrcProcedure = RrcConnectionEstablishmentProcedure({
"maxPrachPreambleAttempts": 5,
"prachPreambleRepeatDelay": 0.7,
"macContentionResolutionTimeout": 0.5,
"rrcConnectionSetupTimeoutT300": 2.0
}, (localhost(), 9000), ueIoService, rrcComplete, {
"ueIdentityType": "randomValue",
"ueIdentityValue": 3434,
"rrcEstablishmentCause": "moSignaling",
"selectedPlmnIdentity": 2801,
"initialNasMessage": {
"nasMessageType": "attachRequest"
},
})
rrcProcedure.execute()
time.sleep(2)
self.assertEqual(self.result, RrcConnectionEstablishmentProcedure.Success)
ueIoService.stop()
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccess, self.hssSuccess = 0, 0
def tearDown(self):
self.hssIoService.stop()
self.mmeIoService.stop()
def __mmeAuthCompleteCallback__(self, result, authContext=None):
self.mmeSuccess += 1
def __hssAuthCompleteCallback__(self, result, imsi):
self.hssSuccess += 1
def test_nAuthInfoRetrievalProcedureSuccess(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccess, n)
self.assertEqual(self.hssSuccess, n)
class Mme(StateMachine):
def __init__(self, name, port, configData):
super(Mme, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.changeState(Default)
def terminate(self):
self.ioService.stop()
class Mme(StateMachine):
def __init__(self, name, port, configData):
super(Mme, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.changeState(Default)
def terminate(self):
self.ioService.stop()
class Enb(StateMachine):
def __init__(self, name, port, configData):
super(Enb, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.config.addListener("control.adminState", self.__onAdminStateChanged__)
self.changeState(Deregistered)
if self.config.getValue("control.adminState"):
self.handleCommand("register")
def __onAdminStateChanged__(self, _, adminState):
mapping = {True: "register", False: "deregister"}
self.handleCommand(mapping[adminState])
def terminate(self):
self.ioService.stop()
class Enb(StateMachine):
def __init__(self, name, port, configData):
super(Enb, self).__init__()
self.ioService = IoService(name, port)
self.config = Configuration(configData, self.ioService)
self.setContext({"config": self.config, "ioService": self.ioService})
def execute(self):
self.ioService.addIncomingMessageCallback(self.handleIncomingMessage)
self.ioService.start()
self.config.addListener("control.adminState",
self.__onAdminStateChanged__)
self.changeState(Deregistered)
if self.config.getValue("control.adminState"):
self.handleCommand("register")
def __onAdminStateChanged__(self, _, adminState):
mapping = {True: "register", False: "deregister"}
self.handleCommand(mapping[adminState])
def terminate(self):
self.ioService.stop()
class TestGtpcCreateSessionProcedureHandler(unittest.TestCase):
def setUp(self):
self.sgwPgwIoService = IoService("sgwPgw", 9000)
self.sgwPgwIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeResult, self.sgwPgwResult = 0, 0
self.mmeSuccessCount, self.mmeFailureCount = 0, 0
def tearDown(self):
self.sgwPgwIoService.stop()
self.mmeIoService.stop()
def __mmeCreateSessionCompleteCallback__(self, result, responseMessageCause=None):
self.mmeResult = result
if result == MmeCreateSessionHandler.Success:
self.mmeSuccessCount += 1
else:
self.mmeFailureCount += 1
def __sgwPgwCreateSessionCompleteCallback__(self, result, sgwContextInfo=None):
self.sgwPgwResult = result
self.sgwContextInfo = sgwContextInfo
# print sgwContextInfo
def test_noCreateSessionResponseReceived(self):
self.mmeResult = None
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9002), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
imsi = "35353"
createSessionRequestMessage = \
{"imsi": imsi,
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"s1uEnbFteid": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(0.5*3 + 0.2)
self.assertEqual(self.mmeResult,
MmeCreateSessionHandler.ErrorNoCreateSessionResponse)
def test_nNoCreateSessionResponseReceived(self):
self.mmeResult = None
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9002), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
for i in range(100):
imsi = "2867" + str(i)
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": i, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"s1uEnbFteid": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(0.5*3 + 0.5)
self.assertEqual(self.mmeFailureCount, 100)
def test_CreateSessionProcedureSuccess(self):
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9000), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
sgwPgwBearerResourceHandler = SgwPgwBearerResourceHandler(localhost(), localhost())
sgwPgwCreateSessionHandler = SgwPgwCreateSessionHandler((localhost(), 9001), localhost(), self.sgwPgwIoService,
sgwPgwBearerResourceHandler, self.__sgwPgwCreateSessionCompleteCallback__)
self.sgwPgwIoService.addIncomingMessageCallback(sgwPgwCreateSessionHandler.handleCreateSessionRequestMessage)
imsi = "35353"
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(1.0)
self.assertEqual(self.mmeResult, MmeCreateSessionHandler.Success)
self.assertEqual(self.sgwPgwResult, SgwPgwCreateSessionHandler.Success)
def test_DuplicateCreateSessionRequestProcedureSuccess(self):
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9000), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
sgwPgwBearerResourceHandler = SgwPgwBearerResourceHandler(localhost(), localhost())
sgwPgwCreateSessionHandler = SgwPgwCreateSessionHandler((localhost(), 9001), localhost(), self.sgwPgwIoService,
sgwPgwBearerResourceHandler, self.__sgwPgwCreateSessionCompleteCallback__)
self.sgwPgwIoService.addIncomingMessageCallback(sgwPgwCreateSessionHandler.handleCreateSessionRequestMessage)
imsi = "35353"
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": 45, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(1.0)
self.assertEqual(self.mmeResult, MmeCreateSessionHandler.Success)
self.assertEqual(self.sgwPgwResult, SgwPgwCreateSessionHandler.Success)
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage) # send duplicate message but with a new sequence number
time.sleep(1.0)
self.assertEqual(self.mmeResult, MmeCreateSessionHandler.Success)
self.assertEqual(self.sgwPgwResult, SgwPgwCreateSessionHandler.Success)
def test_nCreateSessionProcedureSuccess(self):
mmeCreateSessionHandler = MmeCreateSessionHandler((localhost(), 9000), self.mmeIoService, 0.5, 3, self.__mmeCreateSessionCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeCreateSessionHandler.handleIncomingMessage)
sgwPgwBearerResourceHandler = SgwPgwBearerResourceHandler(localhost(), localhost())
sgwPgwCreateSessionHandler = SgwPgwCreateSessionHandler((localhost(), 9001), localhost(), self.sgwPgwIoService,
sgwPgwBearerResourceHandler, self.__sgwPgwCreateSessionCompleteCallback__)
self.sgwPgwIoService.addIncomingMessageCallback(sgwPgwCreateSessionHandler.handleCreateSessionRequestMessage)
imsiArray = []
for i in range(100):
imsi = "2867" + str(i)
imsiArray.append(imsi)
createSessionRequestMessage = \
{"imsi": imsi,
"senderFteidForControlPlane": {"interfaceType": "ipv4", "teid": i, "address": localhost()},
"pgwS5S8AddressForContolPlane": {"interfaceType": "ipv4", "teid": 0,
"address": localhost()},
"pdnAddressAllocation": {"pdnType": "ipv4", "pdnAddressAndPrefix": "0.0.0.0"},
"bearerContextsToBeCreated": [{"epsBearerId": 0,
"bearerLevelQos": None}]
}
mmeCreateSessionHandler.execute(imsi, createSessionRequestMessage)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccessCount, 100)
self.assertEqual(set(sgwPgwCreateSessionHandler.establishedS11SessionContexts), set(imsiArray))
mmeTeidsForControlPlane = []
for i in range(100):
imsi = "2867" + str(i)
mmeTeidsForControlPlane.append(sgwPgwCreateSessionHandler.establishedS11SessionContexts[imsi]["mmeFteidForControlPlane"]["teid"])
self.assertEqual(set(mmeTeidsForControlPlane), set(range(100)))
class TestIoServiceTimers(unittest.TestCase):
def setUp(self):
self.ioservice = IoService("timer", 9000)
self.ioservice.start()
def test_startTimer(self):
def onSuccess():
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_startTimerWithArguments(self):
def onSuccess(*args, **kwargs):
self.assertEqual(args, (1, 2, 3))
self.assertEqual(kwargs, {"kwargOne": 4, "kwargTwo": 5, "kwargThree": 6})
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess, 1, 2, 3, kwargOne=4, kwargTwo=5, kwargThree=6)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_cancelTimer(self):
def onExpiration():
self.expired = True
self.expired = False
foo = self.ioservice.createTimer(0.2, onExpiration)
foo.start()
time.sleep(0.1)
foo.cancel()
time.sleep(0.2)
self.assertFalse(self.expired)
def test_restartTimer(self):
def onExpiration():
self.count += 1
if self.count < 2:
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
self.count = 0
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
time.sleep(0.2)
self.assertEqual(self.count, 2)
def test_restartCanceledTimer(self):
def onExpiration():
self.successful = True
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.05)
foo.cancel()
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def tearDown(self):
self.ioservice.stop()
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.hssIoService = IoService("hss", 9000)
self.hssIoService.start()
self.mmeIoService = IoService("mme", 9001)
self.mmeIoService.start()
self.mmeSuccessCount, self.hssSuccessCount = 0, 0
def tearDown(self):
self.hssIoService.stop()
self.mmeIoService.stop()
def __mmeAuthCompleteCallback__(self, result, authContext=None):
if result == MmeAuthProcedureHandler.Success:
self.mmeSuccessCount += 1
def __hssAuthCompleteCallback__(self, result, imsi):
if result == HssAuthProcedureHandler.Success:
self.hssSuccessCount += 1
def test_nAuthInfoRetrievalProcedureSuccess(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
hssAuthProcHandler.knownIMSIs.append(randomImsi)
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.1)
time.sleep(1.0)
self.assertEqual(self.mmeSuccessCount, n)
self.assertEqual(self.hssSuccessCount, n)
def test_roamingNotAllowedError(self):
visitedPlmnId = "47836"
imsi = "286031595270296"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
mmeAuthProcHandler.execute(imsi, visitedPlmnId)
self.assertEqual(self.mmeSuccessCount,0)
def test_unknownImsiError(self):
n = 10
visitedPlmnId = "28603"
imsi = "286056548201466"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
hssAuthProcHandler.knownIMSIs.append(randomImsi)
mmeAuthProcHandler.execute(imsi, visitedPlmnId)
self.assertEqual(self.mmeSuccessCount,0)
def test_responseTimeoutError(self):
n = 100
visitedPlmnId = "28603"
mmeAuthProcHandler = MmeAuthProcedureHandler((localhost(), 9000), self.mmeIoService, 1, self.__mmeAuthCompleteCallback__)
self.mmeIoService.addIncomingMessageCallback(mmeAuthProcHandler.handleIncomingMessage)
hssAuthProcHandler = HssAuthProcedureHandler(self.hssIoService, self.__hssAuthCompleteCallback__)
self.hssIoService.addIncomingMessageCallback(hssAuthProcHandler.handleIncomingMessage)
for _ in range(n):
randomImsi = visitedPlmnId + "".join([str(random.randrange(0, 10)) for __ in range(10)])
hssAuthProcHandler.knownIMSIs.append(randomImsi)
mmeAuthProcHandler.execute(randomImsi, visitedPlmnId)
time.sleep(0.05)
time.sleep(5.0)
self.assertEqual(self.mmeSuccessCount, n - mmeAuthProcHandler.timeoutCounter)
class TestIoServiceTimers(unittest.TestCase):
def setUp(self):
self.ioservice = IoService("timer", 9000)
self.ioservice.start()
def test_startTimer(self):
def onSuccess():
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_startTimerWithArguments(self):
def onSuccess(*args, **kwargs):
self.assertEqual(args, (1, 2, 3))
self.assertEqual(kwargs, {"kwargOne": 4, "kwargTwo": 5, "kwargThree": 6})
self.successful = True
self.successful = False
foo = self.ioservice.createTimer(0.1, onSuccess, 1, 2, 3, kwargOne=4, kwargTwo=5, kwargThree=6)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def test_cancelTimer(self):
def onExpiration():
self.expired = True
self.expired = False
foo = self.ioservice.createTimer(0.2, onExpiration)
foo.start()
time.sleep(0.1)
foo.cancel()
time.sleep(0.2)
self.assertFalse(self.expired)
def test_restartTimer(self):
def onExpiration():
self.count += 1
if self.count < 2:
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
self.count = 0
foo = self.ioservice.createTimer(0.05, onExpiration)
foo.start()
time.sleep(0.2)
self.assertEqual(self.count, 2)
def test_restartCanceledTimer(self):
def onExpiration():
self.successful = True
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.05)
foo.cancel()
foo = self.ioservice.createTimer(0.1, onExpiration)
foo.start()
time.sleep(0.2)
self.assertTrue(self.successful)
def tearDown(self):
self.ioservice.stop()
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.mmeIoService.start()
self.mmeParameters = {
"mmeName": "Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0,), (12, 13, 14)),
],
"timeToWait": 1,
"flags": {
"rejectS1SetupRequestsFromRegisteredEnbs": True
},
"criticalityDiagnostics": None,
}
self.enbProcedureParameters = lambda globalEnbId, enbName, tac: {
"globalEnbId": globalEnbId,
"enbName": enbName,
"supportedTas": [
(tac, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
}
self.numEnbs = 2
self.enbIoServices = [IoService("enb{}".format(i), 9001 + i) for i in range(self.numEnbs)]
self.enbProcedures = [
EnbS1SetupProcedure(self.enbProcedureParameters(i, "enb{}".format(i), 59900 + i),
(localhost(), 9000), s, self.__enbS1SetupProcedureProgressCallback__)
for i, s in enumerate(self.enbIoServices)]
[s.start() for s in self.enbIoServices]
self.numSuccess, self.numWaitingForNextAttempt = 0, 0
def tearDown(self):
self.mmeProcedureHandler.terminate()
self.mmeIoService.stop()
[p.terminate() for p in self.enbProcedures]
[s.stop() for s in self.enbIoServices]
def __enbS1SetupProcedureProgressCallback__(self, progress, args=None):
if progress == EnbS1SetupProcedure.ProgressSuccess:
self.numSuccess += 1
elif progress == EnbS1SetupProcedure.ProgressWaitForNextAttempt:
self.numWaitingForNextAttempt += 1
def __mmeOnEnbRegisteredCallback__(self, globalEnbId):
self.enbPool.add(globalEnbId)
def test_AllSuccessfulS1Setups(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs)
self.assertEqual(len(self.enbPool), self.numEnbs)
def test_AllSuccessfulS1SetupsExceptOne(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs - 1)
self.assertEqual(self.numWaitingForNextAttempt, 1)
self.assertEqual(len(self.enbPool), self.numEnbs - 1)
class TestConfiguration(unittest.TestCase):
def setUp(self):
self.ioService = IoService("service", 9000)
self.ioService.start()
self.cfg = Configuration(
{
"rrm": {
"t3212": 64,
"csEnabled": True,
"psEnabled": False
},
"son": {
"enabled": True,
"utrafdd": {
"enabled": True,
"scanOnBoot": True,
"freqs": [10787, 9137],
},
"gsm": {
"enabled": True,
"scanOnBoot": True,
"freqs": [514, 516]
}
},
"oam": {
"cliEnabled": True,
"username": "******",
"password": "******"
}
}, self.ioService)
self.result = [None, None]
def tearDown(self):
self.ioService.stop()
def test_setValue(self):
self.cfg.setValue(("oam", "cliEnabled"), False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_setValueWithDotFormat(self):
self.cfg.setValue("oam.cliEnabled", False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_getValue(self):
self.assertEqual(self.cfg.getValue(("oam", "username")), "fap123")
def test_getValueWithDotFormat(self):
self.assertEqual(self.cfg.getValue("oam.username"), "fap123")
def test_listenerCalledOnValueChanged(self):
def onValueChanged(path, value):
self.result = (path, value)
self.cfg.addListener("oam", onValueChanged)
self.cfg.setValue("oam.cliEnabled", False)
time.sleep(0.1)
self.assertListEqual(self.result[0], list(("oam", "cliEnabled")))
self.assertEqual(self.result[1], False)
def test_listenerNotCalledOnValueChanged(self):
self.listenerCalled = False
def onValueChanged(path, value):
self.listenerCalled = True
self.cfg.addListener("oam.cliEnabled", onValueChanged)
self.cfg.setValue("rrm.t3212", 10)
time.sleep(0.1)
self.assertFalse(self.listenerCalled)
class TestConfiguration(unittest.TestCase):
def setUp(self):
self.ioService = IoService("service", 9000)
self.ioService.start()
self.cfg = Configuration({
"rrm": {
"t3212": 64,
"csEnabled": True,
"psEnabled": False
},
"son": {
"enabled": True,
"utrafdd": {
"enabled": True,
"scanOnBoot": True,
"freqs": [10787, 9137],
},
"gsm": {
"enabled": True,
"scanOnBoot": True,
"freqs": [514, 516]
}
},
"oam": {
"cliEnabled": True,
"username": "******",
"password": "******"
}
}, self.ioService)
self.result = [None, None]
def tearDown(self):
self.ioService.stop()
def test_setValue(self):
self.cfg.setValue(("oam", "cliEnabled"), False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_setValueWithDotFormat(self):
self.cfg.setValue("oam.cliEnabled", False)
self.assertFalse(self.cfg.content["oam"]["cliEnabled"])
def test_getValue(self):
self.assertEqual(self.cfg.getValue(("oam", "username")), "fap123")
def test_getValueWithDotFormat(self):
self.assertEqual(self.cfg.getValue("oam.username"), "fap123")
def test_listenerCalledOnValueChanged(self):
def onValueChanged(path, value):
self.result = (path, value)
self.cfg.addListener("oam", onValueChanged)
self.cfg.setValue("oam.cliEnabled", False)
time.sleep(0.1)
self.assertListEqual(self.result[0], list(("oam", "cliEnabled")))
self.assertEqual(self.result[1], False)
def test_listenerNotCalledOnValueChanged(self):
self.listenerCalled = False
def onValueChanged(path, value):
self.listenerCalled = True
self.cfg.addListener("oam.cliEnabled", onValueChanged)
self.cfg.setValue("rrm.t3212", 10)
time.sleep(0.1)
self.assertFalse(self.listenerCalled)
class TestS1SetupProcedureHandler(unittest.TestCase):
def setUp(self):
self.mmeIoService = IoService("mme", 9000)
self.mmeIoService.start()
self.mmeParameters = {
"mmeName":
"Istanbul",
"servedGummeis": [
(("28603", "28604"), (0, 1, 2), (23, 58, 127)),
(("00108"), (0, ), (12, 13, 14)),
],
"timeToWait":
1,
"flags": {
"rejectS1SetupRequestsFromRegisteredEnbs": True
},
"criticalityDiagnostics":
None,
}
self.enbProcedureParameters = lambda globalEnbId, enbName, tac: {
"globalEnbId": globalEnbId,
"enbName": enbName,
"supportedTas": [
(tac, ("28603", "28604")),
],
"csgIdList": [],
"defaultPagingDrx": [32, 64, 128],
}
self.numEnbs = 2
self.enbIoServices = [
IoService("enb{}".format(i), 9001 + i) for i in range(self.numEnbs)
]
self.enbProcedures = [
EnbS1SetupProcedure(
self.enbProcedureParameters(i, "enb{}".format(i),
59900 + i), (localhost(), 9000), s,
self.__enbS1SetupProcedureProgressCallback__)
for i, s in enumerate(self.enbIoServices)
]
[s.start() for s in self.enbIoServices]
self.numSuccess, self.numWaitingForNextAttempt = 0, 0
def tearDown(self):
self.mmeProcedureHandler.terminate()
self.mmeIoService.stop()
[p.terminate() for p in self.enbProcedures]
[s.stop() for s in self.enbIoServices]
def __enbS1SetupProcedureProgressCallback__(self, progress, args=None):
if progress == EnbS1SetupProcedure.ProgressSuccess:
self.numSuccess += 1
elif progress == EnbS1SetupProcedure.ProgressWaitForNextAttempt:
self.numWaitingForNextAttempt += 1
def __mmeOnEnbRegisteredCallback__(self, globalEnbId):
self.enbPool.add(globalEnbId)
def test_AllSuccessfulS1Setups(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(
self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(
self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs)
self.assertEqual(len(self.enbPool), self.numEnbs)
def test_AllSuccessfulS1SetupsExceptOne(self):
self.enbPool = MmeServiceArea(self.numEnbs)
self.mmeProcedureHandler = MmeS1SetupProcedureHandler(
self.mmeParameters, self.enbPool, self.mmeIoService,
self.__mmeOnEnbRegisteredCallback__)
self.mmeIoService.addIncomingMessageCallback(
self.mmeProcedureHandler.handleIncomingS1SetupMessage)
self.mmeProcedureHandler.execute()
[p.execute() for p in self.enbProcedures]
time.sleep(0.9)
self.assertEqual(self.numSuccess, self.numEnbs - 1)
self.assertEqual(self.numWaitingForNextAttempt, 1)
self.assertEqual(len(self.enbPool), self.numEnbs - 1)
