def test_subscription_registered(self):
registration_key = "registered_test"
mock_callback = Mock()
register_subscriber(registration_key)(mock_callback)
with self.tasks():
snuba_query = create_snuba_query(
QueryDatasets.EVENTS,
"hello",
QueryAggregations.TOTAL,
timedelta(minutes=10),
timedelta(minutes=1),
None,
)
sub = create_snuba_subscription(self.project, registration_key,
snuba_query)
sub.refresh_from_db()
data = self.valid_wrapper
data["payload"]["subscription_id"] = sub.subscription_id
self.consumer.handle_message(self.build_mock_message(data))
data = deepcopy(data)
data["payload"]["values"] = data["payload"]["result"]
data["payload"]["timestamp"] = parse_date(
data["payload"]["timestamp"]).replace(tzinfo=pytz.utc)
mock_callback.assert_called_once_with(data["payload"], sub)
def test_normal(self):
cluster_name = settings.KAFKA_TOPICS[self.topic]["cluster"]
conf = {
"bootstrap.servers":
settings.KAFKA_CLUSTERS[cluster_name]["bootstrap.servers"],
"session.timeout.ms":
6000,
}
producer = Producer(conf)
producer.produce(self.topic, json.dumps(self.valid_wrapper))
producer.flush()
mock_callback = Mock()
mock_callback.side_effect = KeyboardInterrupt()
register_subscriber(self.registration_key)(mock_callback)
sub = self.create_subscription()
consumer = QuerySubscriptionConsumer("hi",
topic=self.topic,
commit_batch_size=1)
consumer.run()
payload = self.valid_payload
payload["values"] = payload["result"]
payload["timestamp"] = parse_date(
payload["timestamp"]).replace(tzinfo=pytz.utc)
mock_callback.assert_called_once_with(payload, sub)
def test_rule_processor(self, mock_processor):
event = self.store_event(data={"message": "testing"},
project_id=self.project.id)
cache_key = write_event_to_cache(event)
mock_callback = Mock()
mock_futures = [Mock()]
mock_processor.return_value.apply.return_value = [(mock_callback,
mock_futures)]
post_process_group(
is_new=True,
is_regression=False,
is_new_group_environment=True,
cache_key=cache_key,
group_id=event.group_id,
)
mock_processor.assert_called_once_with(EventMatcher(event), True,
False, True, False)
mock_processor.return_value.apply.assert_called_once_with()
mock_callback.assert_called_once_with(EventMatcher(event),
mock_futures)
def test_normal(self):
cluster_name = settings.KAFKA_TOPICS[self.topic]["cluster"]
conf = {
"bootstrap.servers":
settings.KAFKA_CLUSTERS[cluster_name]["bootstrap.servers"],
"session.timeout.ms":
6000,
}
producer = Producer(conf)
producer.produce(self.topic, json.dumps(self.valid_wrapper))
producer.flush()
mock_callback = Mock()
mock_callback.side_effect = KeyboardInterrupt()
register_subscriber(self.registration_key)(mock_callback)
sub = QuerySubscription.objects.create(
project=self.project,
type=self.registration_key,
subscription_id=self.subscription_id,
dataset="something",
query="hello",
aggregation=0,
time_window=1,
resolution=1,
)
consumer = QuerySubscriptionConsumer("hi",
topic=self.topic,
commit_batch_size=1)
consumer.run()
mock_callback.assert_called_once_with(self.valid_payload, sub)
def test_handled(self):
mock_handler = Mock()
type = AlertRuleTriggerAction.Type.EMAIL
AlertRuleTriggerAction.register_type("something", type, [])(mock_handler)
trigger = AlertRuleTriggerAction(type=AlertRuleTriggerAction.Type.EMAIL.value)
incident = Mock()
project = Mock()
trigger.build_handler(incident, project)
mock_handler.assert_called_once_with(trigger, incident, project)
assert not self.metrics.incr.called
def test(self):
with patch.object(AlertRuleTriggerAction, "_type_registrations", new={}):
mock_handler = Mock()
AlertRuleTriggerAction.register_type("email", AlertRuleTriggerAction.Type.EMAIL, [])(
mock_handler
)
incident = self.create_incident()
metric_value = 1234
with self.tasks():
handle_trigger_action.delay(
self.action.id, incident.id, self.project.id, "fire", metric_value=metric_value
)
mock_handler.assert_called_once_with(self.action, incident, self.project)
mock_handler.return_value.fire.assert_called_once_with(metric_value)
def test_subscription_registered(self):
registration_key = "registered_test"
mock_callback = Mock()
register_subscriber(registration_key)(mock_callback)
sub = QuerySubscription.objects.create(
project=self.project,
type=registration_key,
subscription_id="an_id",
dataset="something",
query="hello",
aggregation=0,
time_window=1,
resolution=1,
)
data = self.valid_wrapper
data["payload"]["subscription_id"] = sub.subscription_id
self.consumer.handle_message(self.build_mock_message(data))
mock_callback.assert_called_once_with(data["payload"], sub)
def test_rule_processor(self, mock_processor):
event = self.store_event(data={}, project_id=self.project.id)
mock_callback = Mock()
mock_futures = [Mock()]
mock_processor.return_value.apply.return_value = [(mock_callback,
mock_futures)]
post_process_group(event=event,
is_new=True,
is_regression=False,
is_new_group_environment=True)
mock_processor.assert_called_once_with(event, True, False, True, False)
mock_processor.return_value.apply.assert_called_once_with()
mock_callback.assert_called_once_with(event, mock_futures)
