Exemplo n.º 1
0
    def test_find_by_instance_id(self):
        """
        Test to retrieve a guest agents by its id
        """
        # create a unique record
        instance_id = str(uuid.uuid4())
        heartbeat = AgentHeartBeat.create(instance_id=instance_id,
                                          guest_agent_version="1.2.3")
        self.assertIsNotNone(heartbeat)
        self.assertIsNotNone(heartbeat.id)
        self.assertIsNotNone(heartbeat.instance_id)
        self.assertEqual(instance_id, heartbeat.instance_id)
        self.assertIsNotNone(heartbeat.updated_at)
        self.assertIsNotNone(heartbeat.guest_agent_version)
        self.assertEqual("1.2.3", heartbeat.guest_agent_version)

        # retrieve the record
        heartbeat_found = AgentHeartBeat.find_by_instance_id(
            instance_id=instance_id)
        self.assertIsNotNone(heartbeat_found)
        self.assertEqual(heartbeat.id, heartbeat_found.id)
        self.assertEqual(heartbeat.instance_id, heartbeat_found.instance_id)
        self.assertEqual(heartbeat.updated_at, heartbeat_found.updated_at)
        self.assertEqual(heartbeat.guest_agent_version,
                         heartbeat_found.guest_agent_version)
    def test_find_by_instance_id(self):
        """
        Test to retrieve a guest agents by it's id
        """
        # create a unique record
        instance_id = str(uuid.uuid4())
        heartbeat = AgentHeartBeat.create(
            instance_id=instance_id, guest_agent_version="1.2.3")
        self.assertIsNotNone(heartbeat)
        self.assertIsNotNone(heartbeat.id)
        self.assertIsNotNone(heartbeat.instance_id)
        self.assertEqual(instance_id, heartbeat.instance_id)
        self.assertIsNotNone(heartbeat.updated_at)
        self.assertIsNotNone(heartbeat.guest_agent_version)
        self.assertEqual("1.2.3", heartbeat.guest_agent_version)

        # retrieve the record
        heartbeat_found = AgentHeartBeat.find_by_instance_id(
            instance_id=instance_id)
        self.assertIsNotNone(heartbeat_found)
        self.assertEqual(heartbeat.id, heartbeat_found.id)
        self.assertEqual(heartbeat.instance_id, heartbeat_found.instance_id)
        self.assertEqual(heartbeat.updated_at, heartbeat_found.updated_at)
        self.assertEqual(heartbeat.guest_agent_version,
                         heartbeat_found.guest_agent_version)
Exemplo n.º 3
0
 def update_db():
     status = InstanceServiceStatus.find_by(instance_id=self.id)
     if instance_name.endswith('GUEST_ERROR'):
         status.status = srvstatus.ServiceStatuses.FAILED
     else:
         status.status = srvstatus.ServiceStatuses.HEALTHY
     status.save()
     AgentHeartBeat.create(instance_id=self.id)
Exemplo n.º 4
0
 def update_db():
     status = InstanceServiceStatus.find_by(instance_id=self.id)
     if instance_name.endswith('GUEST_ERROR'):
         status.status = rd_instance.ServiceStatuses.FAILED
     else:
         status.status = rd_instance.ServiceStatuses.RUNNING
     status.save()
     AgentHeartBeat.create(instance_id=self.id)
 def test_save_invalid_model_error(self):
     """
     Test the save failure of an agent heartbeat record
     """
     instance_id = str(uuid.uuid4())
     heartbeat = AgentHeartBeat.create(
         instance_id=instance_id)
     with patch.object(AgentHeartBeat, 'is_valid', return_value=False):
         self.assertRaises(exception.InvalidModelError, heartbeat.save)
Exemplo n.º 6
0
    def test_find_all_by_version(self):
        """
        Test to retrieve all guest agents with a particular version
        """
        # create some unique records with the same version
        version = str(uuid.uuid4())

        for x in range(5):
            instance_id = str(uuid.uuid4())
            heartbeat = AgentHeartBeat.create(instance_id=instance_id,
                                              guest_agent_version=version,
                                              deleted=0)
            self.assertIsNotNone(heartbeat)

        # get all guests by version
        heartbeats = AgentHeartBeat.find_all_by_version(version)
        self.assertIsNotNone(heartbeats)
        self.assertEqual(5, heartbeats.count())
    def test_find_all_by_version(self):
        """
        Test to retrieve all guest agents with a particular version
        """
        # create some unique records with the same version
        version = str(uuid.uuid4())

        for x in xrange(5):
            instance_id = str(uuid.uuid4())
            heartbeat = AgentHeartBeat.create(
                instance_id=instance_id,
                guest_agent_version=version,
                deleted=0)
            self.assertIsNotNone(heartbeat)

        # get all guests by version
        heartbeats = AgentHeartBeat.find_all_by_version(version)
        self.assertIsNotNone(heartbeats)
        self.assertEqual(5, heartbeats.count())
Exemplo n.º 8
0
    def test_update_heartbeat(self):
        """
        Test to show the upgrade scenario that will be used by conductor
        """
        # create a unique record
        instance_id = str(uuid.uuid4())
        heartbeat = AgentHeartBeat.create(instance_id=instance_id,
                                          guest_agent_version="1.2.3")
        self.assertIsNotNone(heartbeat)
        self.assertIsNotNone(heartbeat.id)
        self.assertIsNotNone(heartbeat.instance_id)
        self.assertEqual(instance_id, heartbeat.instance_id)
        self.assertIsNotNone(heartbeat.updated_at)
        self.assertIsNotNone(heartbeat.guest_agent_version)
        self.assertEqual("1.2.3", heartbeat.guest_agent_version)

        # retrieve the record
        heartbeat_found = AgentHeartBeat.find_by_instance_id(
            instance_id=instance_id)
        self.assertIsNotNone(heartbeat_found)
        self.assertEqual(heartbeat.id, heartbeat_found.id)
        self.assertEqual(heartbeat.instance_id, heartbeat_found.instance_id)
        self.assertEqual(heartbeat.updated_at, heartbeat_found.updated_at)
        self.assertEqual(heartbeat.guest_agent_version,
                         heartbeat_found.guest_agent_version)

        # update
        AgentHeartBeat().update(id=heartbeat_found.id,
                                instance_id=instance_id,
                                guest_agent_version="1.2.3")

        # retrieve the record
        updated_heartbeat = AgentHeartBeat.find_by_instance_id(
            instance_id=instance_id)
        self.assertIsNotNone(updated_heartbeat)
        self.assertEqual(heartbeat.id, updated_heartbeat.id)
        self.assertEqual(heartbeat.instance_id, updated_heartbeat.instance_id)
        self.assertEqual(heartbeat.guest_agent_version,
                         updated_heartbeat.guest_agent_version)

        self.assertEqual(heartbeat.updated_at, updated_heartbeat.updated_at)
    def test_update_heartbeat(self):
        """
        Test to show the upgrade scenario that will be used by conductor
        """
        # create a unique record
        instance_id = str(uuid.uuid4())
        heartbeat = AgentHeartBeat.create(
            instance_id=instance_id, guest_agent_version="1.2.3")
        self.assertIsNotNone(heartbeat)
        self.assertIsNotNone(heartbeat.id)
        self.assertIsNotNone(heartbeat.instance_id)
        self.assertEqual(instance_id, heartbeat.instance_id)
        self.assertIsNotNone(heartbeat.updated_at)
        self.assertIsNotNone(heartbeat.guest_agent_version)
        self.assertEqual("1.2.3", heartbeat.guest_agent_version)

        # retrieve the record
        heartbeat_found = AgentHeartBeat.find_by_instance_id(
            instance_id=instance_id)
        self.assertIsNotNone(heartbeat_found)
        self.assertEqual(heartbeat.id, heartbeat_found.id)
        self.assertEqual(heartbeat.instance_id, heartbeat_found.instance_id)
        self.assertEqual(heartbeat.updated_at, heartbeat_found.updated_at)
        self.assertEqual(heartbeat.guest_agent_version,
                         heartbeat_found.guest_agent_version)

        # update
        AgentHeartBeat().update(id=heartbeat_found.id,
                                instance_id=instance_id,
                                guest_agent_version="1.2.3")

        # retrieve the record
        updated_heartbeat = AgentHeartBeat.find_by_instance_id(
            instance_id=instance_id)
        self.assertIsNotNone(updated_heartbeat)
        self.assertEqual(heartbeat.id, updated_heartbeat.id)
        self.assertEqual(heartbeat.instance_id, updated_heartbeat.instance_id)
        self.assertEqual(heartbeat.guest_agent_version,
                         updated_heartbeat.guest_agent_version)

        self.assertEqual(heartbeat.updated_at, updated_heartbeat.updated_at)
Exemplo n.º 10
0
    def test_find_all_by_version_none(self):
        """
        Test to retrieve all guest agents with a None version
        """
        heartbeats = None
        exception_raised = False
        try:
            heartbeats = AgentHeartBeat.find_all_by_version(None)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeats)
        self.assertTrue(exception_raised)
Exemplo n.º 11
0
    def test_create(self):
        """
        Test the creation of a new agent heartbeat record
        """
        instance_id = str(uuid.uuid4())
        heartbeat = AgentHeartBeat.create(instance_id=instance_id)
        self.assertIsNotNone(heartbeat)

        self.assertIsNotNone(heartbeat.id)
        self.assertIsNotNone(heartbeat.instance_id)
        self.assertEqual(instance_id, heartbeat.instance_id)
        self.assertIsNotNone(heartbeat.updated_at)
        self.assertIsNone(heartbeat.guest_agent_version)
Exemplo n.º 12
0
    def test_find_all_by_version_none(self):
        """
        Test to retrieve all guest agents with a None version
        """
        heartbeats = None
        exception_raised = False
        try:
            heartbeats = AgentHeartBeat.find_all_by_version(None)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeats)
        self.assertTrue(exception_raised)
Exemplo n.º 13
0
    def test_find_by_instance_id_none(self):
        """
        Test to retrieve a guest agents when id is None
        """
        heartbeat_found = None
        exception_raised = False
        try:
            heartbeat_found = AgentHeartBeat.find_by_instance_id(
                instance_id=None)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeat_found)
        self.assertTrue(exception_raised)
Exemplo n.º 14
0
    def test_find_all_by_version_not_found(self):
        """
        Test to retrieve all guest agents with a non-existing version
        """
        version = str(uuid.uuid4())
        exception_raised = False
        heartbeats = None
        try:
            heartbeats = AgentHeartBeat.find_all_by_version(version)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeats)
        self.assertTrue(exception_raised)
Exemplo n.º 15
0
    def test_find_by_instance_id_none(self):
        """
        Test to retrieve a guest agents when id is None
        """
        heartbeat_found = None
        exception_raised = False
        try:
            heartbeat_found = AgentHeartBeat.find_by_instance_id(
                instance_id=None)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeat_found)
        self.assertTrue(exception_raised)
Exemplo n.º 16
0
    def test_find_all_by_version_not_found(self):
        """
        Test to retrieve all guest agents with a non-existing version
        """
        version = str(uuid.uuid4())
        exception_raised = False
        heartbeats = None
        try:
            heartbeats = AgentHeartBeat.find_all_by_version(version)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeats)
        self.assertTrue(exception_raised)
Exemplo n.º 17
0
    def test_find_by_instance_id_not_found(self, mock_logging):
        """
        Test to retrieve a guest agents when id is not found
        """
        instance_id = str(uuid.uuid4())
        heartbeat_found = None
        exception_raised = False
        try:
            heartbeat_found = AgentHeartBeat.find_by_instance_id(
                instance_id=instance_id)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeat_found)
        self.assertTrue(exception_raised)
Exemplo n.º 18
0
    def test_find_by_instance_id_not_found(self, mock_logging):
        """
        Test to retrieve a guest agents when id is not found
        """
        instance_id = str(uuid.uuid4())
        heartbeat_found = None
        exception_raised = False
        try:
            heartbeat_found = AgentHeartBeat.find_by_instance_id(
                instance_id=instance_id)
        except exception.ModelNotFoundError:
            exception_raised = True

        self.assertIsNone(heartbeat_found)
        self.assertTrue(exception_raised)
Exemplo n.º 19
0
    def test_create(self):
        """
        Test the creation of a new agent heartbeat record
        """
        instance_id = str(uuid.uuid4())
        heartbeat = AgentHeartBeat.create(
            instance_id=instance_id)
        self.assertIsNotNone(heartbeat)

        self.assertIsNotNone(heartbeat.id)
        self.assertIsNotNone(heartbeat.instance_id)
        self.assertEqual(instance_id,
                         heartbeat.instance_id)
        self.assertIsNotNone(heartbeat.updated_at)
        self.assertIsNone(heartbeat.guest_agent_version)