def _verify_attr_grouping(self, platform_id, expected_groups):
        attrs = self._get_attrs(platform_id)

        prm = PlatformResourceMonitor(
            platform_id, attrs,
            self._get_attribute_values_dummy, self.evt_recv)

        groups = prm._group_by_monitoring_rate()

        log.debug("groups=\n%s", self._pp.pformat(groups))

        self.assertEquals(len(expected_groups), len(groups))

        for k in expected_groups:
            self.assertIn(k, groups)
            attr_ids = set(d['attr_id'] for d in groups[k])
            self.assertEquals(set(expected_groups[k]), attr_ids)
    def _verify_attr_grouping(self, platform_id, expected_groups):
        attrs = self._get_attrs(platform_id)

        prm = PlatformResourceMonitor(platform_id, attrs,
                                      self._get_attribute_values_dummy,
                                      self.evt_recv)

        groups = prm._group_by_monitoring_rate()

        log.debug("groups=\n%s", self._pp.pformat(groups))

        self.assertEquals(len(expected_groups), len(groups))

        for k in expected_groups:
            self.assertIn(k, groups)
            attr_ids = set(d['attr_id'] for d in groups[k])
            self.assertEquals(set(expected_groups[k]), attr_ids)
    def test_aggregation_for_granule(self):
        platform_id = "LJ01D"
        attrs = self._get_attrs(platform_id)

        prm = PlatformResourceMonitor(platform_id, attrs,
                                      self._get_attribute_values_dummy,
                                      self.evt_recv)

        # set the buffers simulating retrieved data:
        prm._init_buffers()
        bufs = prm._buffers
        # each entry is a list of (val, ts) pairs:
        # note the missing pairs, which should be filled with (None, ts), see below
        bufs["input_voltage"] = [(1000, 9000), (1001, 9001), (1002, 9002)]
        bufs["input_bus_current"] = [(2000, 9000), (2002, 9002)]
        bufs["MVPC_temperature"] = [(3000, 9001)]

        # run the key method under testing:
        prm._dispatch_publication()

        self.assertTrue(self._driver_event,
                        "evt_recv callback must have been called")
        driver_event = self._driver_event

        # buffers must have been re-init'ed:
        for attr_id in attrs:
            self.assertEquals([], prm._buffers[attr_id])

        # this vals_dict is used by PlatformAgent to do the final creation of
        # the granule to be published
        vals_dict = driver_event.vals_dict

        # verify the attributes that must be present:
        self.assertIn("input_voltage", vals_dict)
        self.assertIn("input_bus_current", vals_dict)
        self.assertIn("MVPC_temperature", vals_dict)

        # verify the attribute that must *not* be present:
        # self.assertNotIn("MVPC_pressure_1", vals_dict)

        # verify the expected aligned values so they are on a common set of
        # timestamps:

        input_voltage = vals_dict["input_voltage"]
        input_bus_current = vals_dict["input_bus_current"]
        MVPC_temperature = vals_dict["MVPC_temperature"]

        self.assertEquals([(1000, 9000), (1001, 9001), (1002, 9002)],
                          input_voltage)

        # note the None entries that must have been created

        self.assertEquals([(2000, 9000), (None, 9001), (2002, 9002)],
                          input_bus_current)

        self.assertEquals([(None, 9000), (3000, 9001), (None, 9002)],
                          MVPC_temperature)
    def test_aggregation_for_granule(self):
        platform_id = "LJ01D"
        attrs = self._get_attrs(platform_id)

        prm = PlatformResourceMonitor(
            platform_id, attrs,
            self._get_attribute_values_dummy, self.evt_recv)

        # set the buffers simulating retrieved data:
        prm._init_buffers()
        bufs = prm._buffers
        # each entry is a list of (val, ts) pairs:
        # note the missing pairs, which should be filled with (None, ts), see below
        bufs["input_voltage"]     = [(1000, 9000), (1001, 9001), (1002, 9002)]
        bufs["input_bus_current"] = [(2000, 9000),               (2002, 9002)]
        bufs["MVPC_temperature"]  = [              (3000, 9001)]

        # run the key method under testing:
        prm._dispatch_publication()

        self.assertTrue(self._driver_event, "evt_recv callback must have been called")
        driver_event = self._driver_event

        # buffers must have been re-init'ed:
        for attr_id in attrs:
            self.assertEquals([], prm._buffers[attr_id])

        # this vals_dict is used by PlatformAgent to do the final creation of
        # the granule to be published
        vals_dict = driver_event.vals_dict

        # verify the attributes that must be present:
        self.assertIn("input_voltage", vals_dict)
        self.assertIn("input_bus_current", vals_dict)
        self.assertIn("MVPC_temperature", vals_dict)

        # verify the attribute that must *not* be present:
        self.assertNotIn("MVPC_pressure_1", vals_dict)

        # verify the expected aligned values so they are on a common set of
        # timestamps:

        input_voltage     = vals_dict["input_voltage"]
        input_bus_current = vals_dict["input_bus_current"]
        MVPC_temperature  = vals_dict["MVPC_temperature"]

        self.assertEquals(
            [(1000, 9000), (1001, 9001), (1002, 9002)],
            input_voltage
        )

        # note the None entries that must have been created

        self.assertEquals(
            [(2000, 9000),  (None, 9001), (2002, 9002)],
            input_bus_current
        )

        self.assertEquals(
            [(None, 9000),  (3000, 9001), (None, 9002)],
            MVPC_temperature
        )