コード例 #1
0
    def test_deviceagents(self):
        """Testing method / function db_devagt_get_all_device_agents."""
        # Clear the memory cache
        CACHE.clear()

        # Get results
        response = self.API.get('/infoset/api/v1/deviceagents')
        data = json.loads(response.get_data(as_text=True))
        result = data[0]

        # Verify reponse code
        self.assertEqual(response.status_code, 200)

        # Verify response content
        self.assertEqual(isinstance(data, list), True)
        self.assertEqual(result['idx_device'], self.test_object.idx_device())
        self.assertEqual(result['exists'], self.test_object.exists())
        self.assertEqual(result['enabled'], self.test_object.enabled())
        self.assertEqual(result['idx_agent'], self.test_object.idx_agent())
        self.assertEqual(result['last_timestamp'],
                         self.test_object.last_timestamp())
        self.assertEqual(result['idx_deviceagent'],
                         self.test_object.idx_deviceagent())

        # Test the number and names of keys
        keys = [
            'last_timestamp', 'idx_deviceagent', 'idx_agent', 'idx_device',
            'enabled', 'exists'
        ]
        self.assertEqual(len(result), len(keys))
        for key in keys:
            self.assertEqual(key in result, True)
コード例 #2
0
    def test_getdata_timestamp(self):
        """Testing method / function getdata."""
        # Clear the memory cache
        CACHE.clear()

        # Initialize key variables
        precision = 5
        ts_stop = int(datetime.utcnow().timestamp())
        ts_start = ts_stop - 3600

        # Get results for up to 1/4 hour ago - No data should be present
        uri = ('/infoset/api/v1/datapoints/{}/data?ts_start={}&ts_stop={}'
               ''.format(self.expected['idx_datapoint'], ts_start, ts_stop))
        response = self.API.get(uri)
        result = json.loads(response.get_data(as_text=True))

        # Convert the list of expected values to an easy to compare dict
        check_dict = {}
        for item in self.expected['values']:
            check_dict[str(item['timestamp'])] = item['value']

        # Verify the expected data is there
        for timestamp, value in sorted(result.items()):
            if timestamp in check_dict:
                self.assertEqual(round(result[timestamp], precision),
                                 round(check_dict[timestamp], precision))
            else:
                self.assertEqual(value, 0)
コード例 #3
0
    def test_deviceagents_query(self):
        """Testing method / function db_getidxdeviceagent."""
        # Clear the memory cache
        CACHE.clear()

        # Get results
        uri = ('/infoset/api/v1/deviceagents/{}'
               ''.format(self.expected['idx_deviceagent']))
        response = self.API.get(uri)
        result = json.loads(response.get_data(as_text=True))

        # Verify reponse code
        self.assertEqual(response.status_code, 200)

        # Verify response content
        self.assertEqual(isinstance(result, dict), True)
        self.assertEqual(result['idx_device'], self.test_object.idx_device())
        self.assertEqual(result['exists'], self.test_object.exists())
        self.assertEqual(result['enabled'], self.test_object.enabled())
        self.assertEqual(result['idx_agent'], self.test_object.idx_agent())
        self.assertEqual(result['last_timestamp'],
                         self.test_object.last_timestamp())
        self.assertEqual(result['idx_deviceagent'],
                         self.test_object.idx_deviceagent())

        # Test the number and names of keys
        keys = [
            'last_timestamp', 'idx_deviceagent', 'idx_agent', 'idx_device',
            'enabled', 'exists'
        ]
        self.assertEqual(len(result), len(keys))
        for key in keys:
            self.assertEqual(key in result, True)
コード例 #4
0
ファイル: deviceagents.py プロジェクト: OrandiH/infoset-ng
def db_getidxdeviceagent(value):
    """Get DeviceAgent data from the DB by idx value.

    Args:
        value: idx_deviceagent

    Returns:
        data: JSON data for the selected deviceagent

    """
    # Initialize key variables
    idx_deviceagent = int(value)

    # Get data from cache
    key = ('DB/DeviceAgent/idx_deviceagent/{}'.format(idx_deviceagent))
    cache_value = CACHE.get(key)

    # Process cache miss
    if cache_value is None:
        query = db_deviceagent.GetIDXDeviceAgent(idx_deviceagent)
        data = query.everything()
        CACHE.set(key, data)
    else:
        data = cache_value

    # Return
    return jsonify(data)
コード例 #5
0
ファイル: devices.py プロジェクト: OrandiH/infoset-ng
def db_deviceagent_agentindices(value):
    """Get all agent indices from the DB.

    Args:
        idx_device: Index value of device

    Returns:
        List of agent indices reporting on the device

    """
    # Initialize key variables
    idx_device = int(value)

    # Get data from cache
    key = ('DB/Device/idx_device/{}/agents'.format(idx_device))
    cache_value = CACHE.get(key)

    # Process cache miss
    if cache_value is None:
        data = db_deviceagent.agent_indices(idx_device)
        CACHE.set(key, data)
    else:
        data = cache_value

    # Return
    return jsonify(data)
コード例 #6
0
ファイル: devices.py プロジェクト: OrandiH/infoset-ng
def db_getidxdevice(value):
    """Get device data from the DB by idx value.

    Args:
        value: Index from the Device table

    Returns:
        Home Page

    """
    # Initialize key variables
    idx_device = int(value)

    # Get data from cache
    key = ('DB/Device/idx_device/{}'.format(idx_device))
    cache_value = CACHE.get(key)

    # Process cache miss
    if cache_value is None:
        query = db_device.GetIDXDevice(idx_device)
        data = query.everything()
        CACHE.set(key, data)
    else:
        data = cache_value

    # Return
    return jsonify(data)
コード例 #7
0
    def test_agents_query_2(self):
        """Testing method / function agents_query."""
        # Clear the memory cache
        CACHE.clear()

        # Get results
        uri = ('/infoset/api/v1/agents?id_agent={}'
               ''.format(self.expected['id_agent']))
        response = self.API.get(uri)
        data = json.loads(response.get_data(as_text=True))
        result = data[0]

        # Verify reponse code
        self.assertEqual(response.status_code, 200)

        # Verify response content
        self.assertEqual(isinstance(data, list), True)
        self.assertEqual(result['id_agent'], self.test_object.id_agent())
        self.assertEqual(result['exists'], self.test_object.exists())
        self.assertEqual(result['enabled'], self.test_object.enabled())
        self.assertEqual(result['agent'], self.test_object.agent())

        # Test the number and names of keys
        keys = [
            'idx_agent', 'idx_agentname', 'id_agent', 'enabled', 'agent',
            'exists'
        ]
        self.assertEqual(len(result), len(keys))
        for key in keys:
            self.assertEqual(key in result, True)
コード例 #8
0
    def test_datapoints(self):
        """Testing method / function datapoints."""
        # Clear the memory cache
        CACHE.clear()

        # Get results
        uri = ('/infoset/api/v1/datapoints/{}'.format(
            self.expected['idx_datapoint']))
        response = self.API.get(uri)
        result = json.loads(response.get_data(as_text=True))

        # Verify reponse code
        self.assertEqual(response.status_code, 200)

        # Verify response content
        self.assertEqual(isinstance(result, dict), True)
        self.assertEqual(result['idx_datapoint'],
                         self.test_object.idx_datapoint())
        self.assertEqual(result['id_datapoint'],
                         self.test_object.id_datapoint())
        self.assertEqual(result['idx_deviceagent'],
                         self.test_object.idx_deviceagent())
        self.assertEqual(result['idx_department'],
                         self.test_object.idx_department())
        self.assertEqual(result['idx_billcode'],
                         self.test_object.idx_billcode())
        self.assertEqual(result['agent_label'], self.test_object.agent_label())
        self.assertEqual(result['agent_source'],
                         self.test_object.agent_source())
        self.assertEqual(result['billable'], self.test_object.billable())
        self.assertEqual(result['base_type'], self.test_object.base_type())
        self.assertEqual(result['timefixed_value'],
                         self.test_object.timefixed_value())
        self.assertEqual(result['last_timestamp'],
                         self.test_object.last_timestamp())
        self.assertEqual(result['exists'], self.test_object.exists())
        self.assertEqual(result['enabled'], self.test_object.enabled())

        # Test the number and names of keys
        keys = [
            'idx_datapoint', 'id_datapoint', 'idx_deviceagent',
            'idx_department', 'idx_billcode', 'agent_label', 'agent_source',
            'enabled', 'billable', 'base_type', 'timefixed_value',
            'last_timestamp', 'exists'
        ]
        self.assertEqual(len(result), len(keys))
        for key in keys:
            self.assertEqual(key in result, True)
コード例 #9
0
    def test_getdata_secondsago_1(self):
        """Testing method / function getdata."""
        # Clear the memory cache
        CACHE.clear()

        # Initialize key variables
        precision = 5

        #######################################################################
        # Try an hour ago
        #######################################################################

        # Get results for up to an hour ago
        uri = ('/infoset/api/v1/datapoints/{}/data?secondsago=3600'
               ''.format(self.expected['idx_datapoint']))
        response = self.API.get(uri)
        result = json.loads(response.get_data(as_text=True))

        # Convert the list of expected values to an easy to compare dict
        check_dict = {}
        for item in self.expected['values']:
            check_dict[str(item['timestamp'])] = item['value']

        # Verify the expected data is there
        for timestamp, value in sorted(result.items()):
            if timestamp in check_dict:
                self.assertEqual(round(result[timestamp], precision),
                                 round(check_dict[timestamp], precision))
            else:
                self.assertEqual(value, 0)

        #######################################################################
        # Try an 1/4 ago. No data should be present
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results
        uri = ('/infoset/api/v1/datapoints/{}/data?secondsago=900'
               ''.format(self.expected['idx_datapoint']))
        response = self.API.get(uri)
        result = json.loads(response.get_data(as_text=True))

        # Go through the results
        for timestamp, value in sorted(result.items()):
            self.assertEqual(result[timestamp], 0)
            self.assertEqual(value, 0)
コード例 #10
0
    def test_db_datapoint_summary(self):
        """Testing method / function db_datapoint_summary."""
        # Clear the memory cache
        CACHE.clear()

        # Get results
        uri = '/infoset/api/v1/datapoints/all/summary'
        response = self.API.get(uri)
        data = json.loads(response.get_data(as_text=True))

        # Verify reponse code
        self.assertEqual(response.status_code, 200)

        # Verify response content
        self.assertEqual(isinstance(data, dict), True)
        self.assertEqual(len(data), 1)

        for idx_datapoint, result in data.items():
            self.assertEqual(int(idx_datapoint),
                             self.test_object.idx_datapoint())

            self.assertEqual(result['idx_deviceagent'],
                             self.test_object.idx_deviceagent())
            self.assertEqual(result['agent_label'],
                             self.test_object.agent_label())
            self.assertEqual(result['agent_source'],
                             self.test_object.agent_source())

            # Get remaining values
            self.assertEqual(result['devicename'], self.expected['devicename'])
            self.assertEqual(result['id_agent'], self.expected['id_agent'])
            self.assertEqual(result['agent'], self.expected['agent'])

            # Test the number and names of keys
            keys = [
                'idx_deviceagent', 'agent_label', 'agent_source', 'devicename',
                'id_agent', 'agent'
            ]
            self.assertEqual(len(result), len(keys))
            for key in keys:
                self.assertEqual(key in result, True)

            # All done
            break
コード例 #11
0
    def test_db_deviceagent_indices(self):
        """Testing method / function db_deviceagent_agentindices."""
        # Clear the memory cache
        CACHE.clear()

        # Get results
        uri = (
            '/infoset/api/v1/devices/{}/agents'
            ''.format(self.expected['idx_device'])
        )
        response = self.API.get(uri)
        result = json.loads(response.get_data(as_text=True))

        # Verify reponse code
        self.assertEqual(response.status_code, 200)

        # Verify response content
        self.assertEqual(isinstance(result, list), True)
        self.assertEqual(len(result), 1)
        self.assertEqual(result, [self.expected['idx_agent']])
コード例 #12
0
ファイル: deviceagents.py プロジェクト: OrandiH/infoset-ng
def db_devagt_get_all_device_agents():
    """Get all DeviceAgent data from the DB.

    Args:
        None

    Returns:
        Agent data

    """
    # Get data from cache
    key = ('DB/DeviceAgent')
    cache_value = CACHE.get(key)

    # Process cache miss
    if cache_value is None:
        data = db_deviceagent.get_all_device_agents()
        CACHE.set(key, data)
    else:
        data = cache_value

    # Return
    return jsonify(data)
コード例 #13
0
ファイル: agents.py プロジェクト: OrandiH/infoset-ng
def agents(idx_agent):
    """Get Agent data from the DB by idx value.

    Args:
        idx_agent: Agent table idx_agent

    Returns:
        data: JSON data for the selected agent

    """
    # Get data from cache
    key = ('DB/Agent/idx_agent/{}'.format(idx_agent))
    cache_value = CACHE.get(key)

    # Process cache miss
    if cache_value is None:
        query = db_agent.GetIDXAgent(general.integerize(idx_agent))
        data = query.everything()
        CACHE.set(key, data)
    else:
        data = cache_value

    # Return
    return jsonify(data)
コード例 #14
0
ファイル: agents.py プロジェクト: OrandiH/infoset-ng
def agents_query():
    """Get Agent data from the DB by id_agent value.

    Args:
        None

    Returns:
        data: JSON data for the selected agent

    """
    # Initialize key variables
    id_agent = request.args.get('id_agent')

    if bool(id_agent) is True:
        # Process id_datapoint request
        key = ('DB/Agent/id_agent/{}'.format(id_agent))
        cache_value = CACHE.get(key)

        # Process cache miss
        if cache_value is None:
            query = db_agent.GetIDAgent(id_agent)
            data = query.everything()
            CACHE.set(key, data)
        else:
            data = cache_value
    else:
        # Process general request
        key = ('DB/Agent/id_agent')
        cache_value = CACHE.get(key)

        # Process cache miss
        if cache_value is None:
            data = db_agent.get_all_agents()
            CACHE.set(key, data)
        else:
            data = cache_value

    # Return
    return jsonify(data)
コード例 #15
0
    def test_lastcontacts(self):
        """Testing method / function lastcontacts."""
        # Initialize key variables
        precision = 5

        #######################################################################
        # Try with secondsago = 3600
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        uri = '/infoset/api/v1/lastcontacts?secondsago=3600'
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Test
        self.assertEqual(isinstance(results, list), True)

        # First item in expected should be the most recent contact.
        # Expected['values'] is sorted by timestamp.
        expected = self.expected['values'][0]
        result = results[0]

        self.assertEqual(result['timestamp'], expected['timestamp'])
        self.assertEqual(
            round(result['value'], precision),
            round(expected['value'], precision))

        #######################################################################
        # Try with secondsago = 60 (No values expected)
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to a minute ago
        uri = '/infoset/api/v1/lastcontacts?secondsago=60'
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Test
        self.assertEqual(isinstance(results, list), True)
        self.assertEqual(bool(results), False)

        #######################################################################
        # Try with ts_start = 0
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results
        uri = '/infoset/api/v1/lastcontacts?ts_start=0'
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Test
        self.assertEqual(isinstance(results, list), True)

        # First item in expected should be the most recent contact.
        # Expected['values'] is sorted by timestamp.
        expected = self.expected['values'][0]
        result = results[0]

        self.assertEqual(result['timestamp'], expected['timestamp'])
        self.assertEqual(
            round(result['value'], precision),
            round(expected['value'], precision))

        #######################################################################
        # Try with ts_start = an hour ago
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        ts_start = int(datetime.utcnow().timestamp()) - 3600
        uri = '/infoset/api/v1/lastcontacts?ts_start={}'.format(ts_start)
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Test
        self.assertEqual(isinstance(results, list), True)

        # First item in expected should be the most recent contact.
        # Expected['values'] is sorted by timestamp.
        expected = self.expected['values'][0]
        result = results[0]

        self.assertEqual(result['timestamp'], expected['timestamp'])
        self.assertEqual(
            round(result['value'], precision),
            round(expected['value'], precision))

        #######################################################################
        # Try with ts_start = a minute ago
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        ts_start = int(datetime.utcnow().timestamp()) - 60
        uri = '/infoset/api/v1/lastcontacts?ts_start={}'.format(ts_start)
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Test type of result
        self.assertEqual(isinstance(results, list), True)
        self.assertEqual(bool(results), False)
コード例 #16
0
    def test_id_agents(self):
        """Testing method / function id_agents."""
        # Initialize key variables
        precision = 5

        #######################################################################
        # Try with default values
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        uri = '/infoset/api/v1/lastcontacts/id_agents'
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Further testing
        result = results[0]
        self.assertEqual(result['agent'], self.expected['agent'])
        self.assertEqual(result['devicename'], self.expected['devicename'])
        self.assertEqual(result['id_agent'], self.expected['id_agent'])
        self.assertEqual('timeseries' in result, True)

        # First item in expected should be the most recent contact.
        # Expected['values'] is sorted by timestamp.
        expected = self.expected['values'][0]

        # We should only have a single result to test
        for agent_label, data_dict in result['timeseries'].items():
            # Test match for agent_label
            self.assertEqual(agent_label, self.expected['agent_label'])

            for key, value in data_dict.items():
                # Test presence of timeseries values
                if key == 'timestamp':
                    self.assertEqual(value, expected['timestamp'])
                elif key == 'value':
                    self.assertEqual(
                        round(value, precision),
                        round(expected['value'], precision))

        #######################################################################
        # Try with secondsago = 3600
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        uri = '/infoset/api/v1/lastcontacts/id_agents?secondsago=3600'
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Further testing
        result = results[0]
        self.assertEqual(result['agent'], self.expected['agent'])
        self.assertEqual(result['devicename'], self.expected['devicename'])
        self.assertEqual(result['id_agent'], self.expected['id_agent'])
        self.assertEqual('timeseries' in result, True)

        # First item in expected should be the most recent contact.
        # Expected['values'] is sorted by timestamp.
        expected = self.expected['values'][0]

        # We should only have a single result to test
        for agent_label, data_dict in result['timeseries'].items():
            # Test match for agent_label
            self.assertEqual(agent_label, self.expected['agent_label'])

            for key, value in data_dict.items():
                # Test presence of timeseries values
                if key == 'timestamp':
                    self.assertEqual(value, expected['timestamp'])
                elif key == 'value':
                    self.assertEqual(
                        round(value, precision),
                        round(expected['value'], precision))

        #######################################################################
        # Try with secondsago = 60 (No response expected)
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        uri = '/infoset/api/v1/lastcontacts/id_agents?secondsago=60'
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Test
        self.assertEqual(isinstance(results, list), True)
        self.assertEqual(bool(results), False)

        #######################################################################
        # Try with ts_star = 0
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        uri = '/infoset/api/v1/lastcontacts/id_agents?ts_start=0'
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Further testing
        result = results[0]
        self.assertEqual(result['agent'], self.expected['agent'])
        self.assertEqual(result['devicename'], self.expected['devicename'])
        self.assertEqual(result['id_agent'], self.expected['id_agent'])
        self.assertEqual('timeseries' in result, True)

        # First item in expected should be the most recent contact.
        # Expected['values'] is sorted by timestamp.
        expected = self.expected['values'][0]

        # We should only have a single result to test
        for agent_label, data_dict in result['timeseries'].items():
            # Test match for agent_label
            self.assertEqual(agent_label, self.expected['agent_label'])

            for key, value in data_dict.items():
                # Test presence of timeseries values
                if key == 'timestamp':
                    self.assertEqual(value, expected['timestamp'])
                elif key == 'value':
                    self.assertEqual(
                        round(value, precision),
                        round(expected['value'], precision))

        #######################################################################
        # Try with ts_start = an hour ago
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        ts_start = int(datetime.utcnow().timestamp()) - 3600
        uri = (
            '/infoset/api/v1/lastcontacts/id_agents?ts_start={}'
            ''.format(ts_start))
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Further testing
        result = results[0]
        self.assertEqual(result['agent'], self.expected['agent'])
        self.assertEqual(result['devicename'], self.expected['devicename'])
        self.assertEqual(result['id_agent'], self.expected['id_agent'])
        self.assertEqual('timeseries' in result, True)

        # First item in expected should be the most recent contact.
        # Expected['values'] is sorted by timestamp.
        expected = self.expected['values'][0]

        # We should only have a single result to test
        for agent_label, data_dict in result['timeseries'].items():
            # Test match for agent_label
            self.assertEqual(agent_label, self.expected['agent_label'])

            for key, value in data_dict.items():
                # Test presence of timeseries values
                if key == 'timestamp':
                    self.assertEqual(value, expected['timestamp'])
                elif key == 'value':
                    self.assertEqual(
                        round(value, precision),
                        round(expected['value'], precision))

        #######################################################################
        # Try with ts_start = 15 minutes ago (No values expected)
        #######################################################################

        # Clear the memory cache
        CACHE.clear()

        # Get results for up to an hour ago
        ts_start = int(datetime.utcnow().timestamp()) - 900
        uri = (
            '/infoset/api/v1/lastcontacts/id_agents?ts_start={}'
            ''.format(ts_start))
        response = self.API.get(uri)
        results = json.loads(response.get_data(as_text=True))

        # Test
        self.assertEqual(isinstance(results, list), True)
        self.assertEqual(bool(results), False)