def test_get_numeric_metric__invalid_value_tag(self):
   """ Test that numeric value is not returned when value event tag has invalid data type. """
   self.assertIsNone(event_tag_utils.get_numeric_value({'value': None}))
   self.assertIsNone(event_tag_utils.get_numeric_value({'value': True}))
   self.assertIsNone(event_tag_utils.get_numeric_value({'value': False}))
   self.assertIsNone(event_tag_utils.get_numeric_value({'value': [1, 2, 3]}))
   self.assertIsNone(event_tag_utils.get_numeric_value({'value': {'a', 'b', 'c'}}))
示例#2
0
 def test_get_numeric_metric__invalid_value_tag(self):
     """ Test that numeric value is not returned when value event tag has invalid data type. """
     self.assertIsNone(event_tag_utils.get_numeric_value({'value': None}))
     self.assertIsNone(event_tag_utils.get_numeric_value({'value': True}))
     self.assertIsNone(event_tag_utils.get_numeric_value({'value': False}))
     self.assertIsNone(
         event_tag_utils.get_numeric_value({'value': [1, 2, 3]}))
     self.assertIsNone(
         event_tag_utils.get_numeric_value({'value': {'a', 'b', 'c'}}))
示例#3
0
    def _create_visitor(cls, event, logger):
        """ Helper method to create Visitor instance for event_batch.

    Args:
      event: Instance of UserEvent.
      logger: Provides a logger instance.

    Returns:
      Instance of Visitor. None if:
      - event is invalid.
    """

        if isinstance(event, user_event.ImpressionEvent):
            metadata = payload.Metadata(event.flag_key, event.rule_key,
                                        event.rule_type, event.variation.key)
            decision = payload.Decision(event.experiment.layerId,
                                        event.experiment.id,
                                        event.variation.id, metadata)
            snapshot_event = payload.SnapshotEvent(
                event.experiment.layerId,
                event.uuid,
                cls.ACTIVATE_EVENT_KEY,
                event.timestamp,
            )

            snapshot = payload.Snapshot([snapshot_event], [decision])

            visitor = payload.Visitor([snapshot], event.visitor_attributes,
                                      event.user_id)

            return visitor

        elif isinstance(event, user_event.ConversionEvent):
            revenue = event_tag_utils.get_revenue_value(event.event_tags)
            value = event_tag_utils.get_numeric_value(event.event_tags, logger)

            snapshot_event = payload.SnapshotEvent(
                event.event.id,
                event.uuid,
                event.event.key,
                event.timestamp,
                revenue,
                value,
                event.event_tags,
            )

            snapshot = payload.Snapshot([snapshot_event])

            visitor = payload.Visitor([snapshot], event.visitor_attributes,
                                      event.user_id)

            return visitor

        else:
            logger.error('Invalid user event.')
            return None
 def test_get_numeric_metric__invalid_args(self):
   """ Test that numeric value is not returned for invalid arguments. """
   self.assertIsNone(event_tag_utils.get_numeric_value(None))
   self.assertIsNone(event_tag_utils.get_numeric_value(0.5))
   self.assertIsNone(event_tag_utils.get_numeric_value(65536))
   self.assertIsNone(event_tag_utils.get_numeric_value(9223372036854775807))
   self.assertIsNone(event_tag_utils.get_numeric_value('9223372036854775807'))
   self.assertIsNone(event_tag_utils.get_numeric_value(True))
   self.assertIsNone(event_tag_utils.get_numeric_value(False))
示例#5
0
 def test_get_numeric_metric__invalid_args(self):
     """ Test that numeric value is not returned for invalid arguments. """
     self.assertIsNone(event_tag_utils.get_numeric_value(None))
     self.assertIsNone(event_tag_utils.get_numeric_value(0.5))
     self.assertIsNone(event_tag_utils.get_numeric_value(65536))
     self.assertIsNone(
         event_tag_utils.get_numeric_value(9223372036854775807))
     self.assertIsNone(
         event_tag_utils.get_numeric_value('9223372036854775807'))
     self.assertIsNone(event_tag_utils.get_numeric_value(True))
     self.assertIsNone(event_tag_utils.get_numeric_value(False))
  def test_get_numeric_metric__value_tag(self):
    """ Test that the correct numeric value is returned. """

    # An integer should be cast to a float
    self.assertEqual(12345.0, event_tag_utils.get_numeric_value({'value': 12345}, logger=logger.SimpleLogger()))

    # A string should be cast to a float
    self.assertEqual(12345.0, event_tag_utils.get_numeric_value({'value': '12345'}, logger=logger.SimpleLogger()))

    # Valid float values
    some_float = 1.2345
    self.assertEqual(some_float, event_tag_utils.get_numeric_value({'value': some_float}, logger=logger.SimpleLogger()))

    max_float = sys.float_info.max
    self.assertEqual(max_float, event_tag_utils.get_numeric_value({'value': max_float}, logger=logger.SimpleLogger()))

    min_float = sys.float_info.min
    self.assertEqual(min_float, event_tag_utils.get_numeric_value({'value': min_float}, logger=logger.SimpleLogger()))

    # Invalid values
    self.assertIsNone(event_tag_utils.get_numeric_value({'value': False}, logger=logger.SimpleLogger()))
    self.assertIsNone(event_tag_utils.get_numeric_value({'value': None}, logger=logger.SimpleLogger()))

    numeric_value_nan = event_tag_utils.get_numeric_value({'value': float('nan')}, logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_nan, 'nan numeric value is {}'.format(numeric_value_nan))

    numeric_value_array = event_tag_utils.get_numeric_value({'value': []}, logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_array, 'Array numeric value is {}'.format(numeric_value_array))

    numeric_value_dict = event_tag_utils.get_numeric_value({'value': []}, logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_dict, 'Dict numeric value is {}'.format(numeric_value_dict))

    numeric_value_none = event_tag_utils.get_numeric_value({'value': None}, logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_none, 'None numeric value is {}'.format(numeric_value_none))

    numeric_value_invalid_literal = event_tag_utils.get_numeric_value({'value': '1,234'}, logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_invalid_literal, 'Invalid string literal value is {}'
                      .format(numeric_value_invalid_literal))

    numeric_value_overflow = event_tag_utils.get_numeric_value({'value': sys.float_info.max * 10},
                                                               logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_overflow, 'Max numeric value is {}'.format(numeric_value_overflow))

    numeric_value_inf = event_tag_utils.get_numeric_value({'value': float('inf')}, logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_inf, 'Infinity numeric value is {}'.format(numeric_value_inf))

    numeric_value_neg_inf = event_tag_utils.get_numeric_value({'value': float('-inf')}, logger=logger.SimpleLogger())
    self.assertIsNone(numeric_value_neg_inf, 'Negative infinity numeric value is {}'.format(numeric_value_neg_inf))

    self.assertEqual(0.0, event_tag_utils.get_numeric_value({'value': 0.0}, logger=logger.SimpleLogger()))
 def test_get_numeric_metric__no_value_tag(self):
   """ Test that numeric value is not returned when there's no numeric event tag. """
   self.assertIsNone(event_tag_utils.get_numeric_value([]))
   self.assertIsNone(event_tag_utils.get_numeric_value({}))
   self.assertIsNone(event_tag_utils.get_numeric_value({'non-value': 42}))
示例#8
0
    def test_get_numeric_metric__value_tag(self):
        """ Test that the correct numeric value is returned. """

        # An integer should be cast to a float
        self.assertEqual(
            12345.0,
            event_tag_utils.get_numeric_value({'value': 12345},
                                              logger=logger.SimpleLogger()))

        # A string should be cast to a float
        self.assertEqual(
            12345.0,
            event_tag_utils.get_numeric_value({'value': '12345'},
                                              logger=logger.SimpleLogger()))

        # Valid float values
        some_float = 1.2345
        self.assertEqual(
            some_float,
            event_tag_utils.get_numeric_value({'value': some_float},
                                              logger=logger.SimpleLogger()))

        max_float = sys.float_info.max
        self.assertEqual(
            max_float,
            event_tag_utils.get_numeric_value({'value': max_float},
                                              logger=logger.SimpleLogger()))

        min_float = sys.float_info.min
        self.assertEqual(
            min_float,
            event_tag_utils.get_numeric_value({'value': min_float},
                                              logger=logger.SimpleLogger()))

        # Invalid values
        self.assertIsNone(
            event_tag_utils.get_numeric_value({'value': False},
                                              logger=logger.SimpleLogger()))
        self.assertIsNone(
            event_tag_utils.get_numeric_value({'value': None},
                                              logger=logger.SimpleLogger()))

        numeric_value_nan = event_tag_utils.get_numeric_value(
            {'value': float('nan')}, logger=logger.SimpleLogger())
        self.assertIsNone(numeric_value_nan,
                          'nan numeric value is {}'.format(numeric_value_nan))

        numeric_value_array = event_tag_utils.get_numeric_value(
            {'value': []}, logger=logger.SimpleLogger())
        self.assertIsNone(
            numeric_value_array,
            'Array numeric value is {}'.format(numeric_value_array))

        numeric_value_dict = event_tag_utils.get_numeric_value(
            {'value': []}, logger=logger.SimpleLogger())
        self.assertIsNone(
            numeric_value_dict,
            'Dict numeric value is {}'.format(numeric_value_dict))

        numeric_value_none = event_tag_utils.get_numeric_value(
            {'value': None}, logger=logger.SimpleLogger())
        self.assertIsNone(
            numeric_value_none,
            'None numeric value is {}'.format(numeric_value_none))

        numeric_value_invalid_literal = event_tag_utils.get_numeric_value(
            {'value': '1,234'}, logger=logger.SimpleLogger())
        self.assertIsNone(
            numeric_value_invalid_literal,
            'Invalid string literal value is {}'.format(
                numeric_value_invalid_literal))

        numeric_value_overflow = event_tag_utils.get_numeric_value(
            {'value': sys.float_info.max * 10}, logger=logger.SimpleLogger())
        self.assertIsNone(
            numeric_value_overflow,
            'Max numeric value is {}'.format(numeric_value_overflow))

        numeric_value_inf = event_tag_utils.get_numeric_value(
            {'value': float('inf')}, logger=logger.SimpleLogger())
        self.assertIsNone(
            numeric_value_inf,
            'Infinity numeric value is {}'.format(numeric_value_inf))

        numeric_value_neg_inf = event_tag_utils.get_numeric_value(
            {'value': float('-inf')}, logger=logger.SimpleLogger())
        self.assertIsNone(
            numeric_value_neg_inf,
            'Negative infinity numeric value is {}'.format(
                numeric_value_neg_inf))

        self.assertEqual(
            0.0,
            event_tag_utils.get_numeric_value({'value': 0.0},
                                              logger=logger.SimpleLogger()))
示例#9
0
 def test_get_numeric_metric__no_value_tag(self):
     """ Test that numeric value is not returned when there's no numeric event tag. """
     self.assertIsNone(event_tag_utils.get_numeric_value([]))
     self.assertIsNone(event_tag_utils.get_numeric_value({}))
     self.assertIsNone(event_tag_utils.get_numeric_value({'non-value': 42}))