def test_SpecifyThatBaseEntityCanBeConstructed(self):
# arrange
baseEntity = BaseEntity(self.EntityId)
# assert
self.assertEqual(baseEntity.Id, self.EntityId)
self.assertEqual(baseEntity.EntityType.value, -1)
self.assertEqual(baseEntity.IsTagged(), False)
def test_SpecifyThatEntityTypeCanBeModify(self):
# arrange
baseEntity = BaseEntity(self.EntityId)
# act
baseEntity.EntityType = TestEntity.TestEntityOne
# assert
self.assertEqual(baseEntity.EntityType, TestEntity.TestEntityOne)
def test_SpecifyThatOnTelegramReturnsFalse(self):
# arrange
entity = BaseEntity(self.EntityId)
state = State()
# assert
self.assertFalse(state.OnTelegram(entity, None))
def test_SpecifyThatExecuteThrowsNotImplementedError(self):
# arrange
entity = BaseEntity(self.EntityId)
state = State()
# assert
self.assertRaises(NotImplementedError, state.Execute, entity)
def test_SpecifyThatNextValidIdCanBeReset(self):
newBaseEntity = None
# arrange
for i in range(0, 5):
newBaseEntity = BaseEntity(i)
# assert
self.assertEqual(newBaseEntity.Id, 4)
self.assertEqual(BaseEntity.GetNextValidId(), 5)
# act
BaseEntity.ResetNextValidId()
# assert
self.assertEqual(BaseEntity.GetNextValidId(), 0)
def test_SpecifyThatExitDoesNotThrowANotImplementedError(self):
# arrange
entity = BaseEntity(self.EntityId)
state = State()
# assert
try:
state.Exit(entity)
except:
self.fail('Exit() should not throw an exception')
def test_SpecifyThatAStateMachineCanBeConstructed(self):
# arrange
entity = BaseEntity(self.EntityId)
stateMachine = StateMachine(entity)
# assert
self.assertEqual(stateMachine.Owner, entity)
self.assertEqual(stateMachine.CurrentState, None)
self.assertEqual(stateMachine.PreviousState, None)
self.assertEqual(stateMachine.GlobalState, None)
def test_SpecifyThatTriggersCanBeUpdated(self):
# arrange
BaseEntity.ResetNextValidId()
trigger = Trigger(1)
trigger.Update = mock.Mock()
triggerSystem = TriggerSystem()
triggerSystem.Register(trigger)
# act
triggerSystem.UpdateTriggers()
# assert
trigger.Update.assert_called()
def test_SpecifyThatTagCanBeSetAndCleared(self):
# arrange
baseEntity = BaseEntity(self.EntityId)
# assert
self.assertEqual(baseEntity.IsTagged(), False)
baseEntity.Tag()
self.assertEqual(baseEntity.IsTagged(), True)
baseEntity.UnTag()
self.assertEqual(baseEntity.IsTagged(), False)
def test_SpecifyThatTriggersCanBeRegisteredAndCleared(self):
BaseEntity.ResetNextValidId()
triggerSystem = TriggerSystem()
self.assertEqual(0, len(triggerSystem.GetTriggers()), "len 1")
triggerSystem.Register(Trigger(1))
triggerSystem.Register(Trigger(2))
self.assertEqual(2, len(triggerSystem.GetTriggers()), "len 2")
triggerSystem.Clear()
self.assertEqual(0, len(triggerSystem.GetTriggers()), "len 3")
def test_SpecifyThatEntityEngineCanBeConstructed(self):
# Ensure that all singletons are reset
self.assertEqual(0, BaseEntity.GetNextValidId(), "GetNextValidId 1")
self.assertEqual({}, EntityManager._getEntityMap(), "_getEntityMap 1")
self.assertEqual(True,
TelegramDispatcher().PriorityQ.IsEmpty(),
"PriorityQ 1")
# Create the engine
entityEngine = self.CreateTestEntityEngine()
# Get references to objects under test
entityMap = EntityManager._getEntityMap()
actionMap = entityEngine._actionMap
entityOne = entityMap[0]
entityTwo = entityMap[1]
# Assert singletons
self.assertEqual(True,
TelegramDispatcher().PriorityQ.IsEmpty(),
"PriorityQ 2")
# Assert entityMap
self.assertEqual(2, len(entityMap), "len(entityMap)")
self.assertEqual("TestEntityOne",
type(entityMap[0]).__name__, "entityMap[0]")
self.assertEqual("TestEntityTwo",
type(entityMap[1]).__name__, "entityMap[1]")
self.assertEqual(0, entityMap[0].Id, "entityMap[0].Id")
self.assertEqual(1, entityMap[1].Id, "entityMap[1].Id")
# Assert actionMap
self.assertEqual(4, len(actionMap), "len(actionMap)")
self.assertEqual("ActionOn", list(actionMap.keys())[0], "key 0")
self.assertEqual("ActionOff", list(actionMap.keys())[1], "key 1")
self.assertEqual("ActionEnable", list(actionMap.keys())[2], "key 2")
self.assertEqual("ActionDisable", list(actionMap.keys())[3], "key 3")
self.assertEqual(actionMap['ActionOn']['FunctionToExecute'],
entityOne.ActionOn)
self.assertEqual(actionMap['ActionOff']['FunctionToExecute'],
entityOne.ActionOff)
self.assertEqual(actionMap['ActionEnable']['FunctionToExecute'],
entityTwo.ActionEnable)
self.assertEqual(actionMap['ActionDisable']['FunctionToExecute'],
entityTwo.ActionDisable)
def __init__(self, firestoreClient, entities):
self._firestoreClient = firestoreClient
self._entities = entities
self._actionMap = {}
BaseEntity.ResetNextValidId()
TelegramDispatcher().Clear()
for entity in self._entities:
EntityManager.RegisterEntity(entity)
self._actionMap.update(entity.ActionMap)
transactionsRef = self._firestoreClient \
.collection(DIALOG_FLOW_TRANSACTIONS_URL) \
.where('status', '==', 'UNPROCESSED')
self._transactionListener = transactionsRef.on_snapshot(self._processRequests)
def test_SpecifyThatUpdateThrowsNotImplementedError(self):
# arrange
baseEntity = BaseEntity(self.EntityId)
# assert
self.assertRaises(NotImplementedError, baseEntity.Update)
def __init__(self, lifeTimeInNumberOfUpdates):
super().__init__(BaseEntity.GetNextValidId())
# the lifetime of this trigger in update-steps
self._lifetime = lifeTimeInNumberOfUpdates
def CreateTriggerLimitedLifetime():
BaseEntity.ResetNextValidId()
return TriggerLimitedLifetime(10)
def tearDown(self):
EntityManager.Reset()
BaseEntity.ResetNextValidId()
TelegramDispatcher().Clear()
def test_SpecifyThatHandleMessageThrowsNotImplementedError(self):
# arrange
baseEntity = BaseEntity(self.EntityId)
# assert
self.assertRaises(NotImplementedError, baseEntity.HandleTelegram, None)
def test_SpecifyThatActionMapThrowsNotImplementedError(self):
# arrange
baseEntity = BaseEntity(self.EntityId)
# assert
self.assertRaises(NotImplementedError, lambda: baseEntity.ActionMap)
def CreateTestBot():
BaseEntity.ResetNextValidId()
return TestBot(1)
def tearDown(self):
EntityManager.Reset()
BaseEntity.ResetNextValidId()
def tearDown(self):
BaseEntity.ResetNextValidId()
def CreateStateMachine(self):
BaseEntity.ResetNextValidId()
entity = BaseEntity(self.EntityId)
stateMachine = StateMachine(entity)
return stateMachine
def CreateUser():
BaseEntity.ResetNextValidId()
return User(entityId=1)
def CreateTestTrigger():
BaseEntity.ResetNextValidId()
return Trigger(1)
def CreateTriggerRespawning():
BaseEntity.ResetNextValidId()
triggerRespawning = TriggerRespawning(1)
triggerRespawning.SetRespawnDelay(10)
return triggerRespawning
