Add DataSources test for future backports

Signed-off-by: Ashish Agrawal <[email protected]>

Author: lezzago

alerting/src/test/kotlin/org/opensearch/alerting/MonitorDataSourcesIT.kt

@@ -0,0 +1,236 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.alerting
+
+import org.junit.Assert
+import org.opensearch.action.admin.indices.create.CreateIndexRequest
+import org.opensearch.alerting.action.GetAlertsAction
+import org.opensearch.alerting.action.GetAlertsRequest
+import org.opensearch.alerting.core.ScheduledJobIndices
+import org.opensearch.alerting.core.model.DocLevelMonitorInput
+import org.opensearch.alerting.core.model.DocLevelQuery
+import org.opensearch.alerting.core.model.ScheduledJob.Companion.SCHEDULED_JOBS_INDEX
+import org.opensearch.alerting.model.Table
+import org.opensearch.alerting.transport.AlertingSingleNodeTestCase
+import org.opensearch.common.settings.Settings
+import java.time.ZonedDateTime
+import java.time.format.DateTimeFormatter
+import java.time.temporal.ChronoUnit.MILLIS
+
+/**
+ * For 2.3 this was backported and some of the tests are not consistent
+ * due to missing features launched in newer versions
+ */
+class MonitorDataSourcesIT : AlertingSingleNodeTestCase() {
+
+    fun `test execute monitor with dryrun`() {
+        val docQuery = DocLevelQuery(query = "test_field:\"us-west-2\"", name = "3")
+        val docLevelInput = DocLevelMonitorInput("description", listOf(index), listOf(docQuery))
+        val trigger = randomDocumentLevelTrigger(condition = ALWAYS_RUN)
+        var monitor = randomDocumentLevelMonitor(
+            inputs = listOf(docLevelInput),
+            triggers = listOf(trigger),
+        )
+        val monitorResponse = createMonitor(monitor)
+        val testTime = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(ZonedDateTime.now().truncatedTo(MILLIS))
+        val testDoc = """{
+            "message" : "This is an error from IAD region",
+            "test_strict_date_time" : "$testTime",
+            "test_field" : "us-west-2"
+        }"""
+        assertFalse(monitorResponse?.id.isNullOrEmpty())
+        monitor = monitorResponse!!.monitor
+        indexDoc(index, "1", testDoc)
+        val id = monitorResponse.id
+        val executeMonitorResponse = executeMonitor(monitor, id, true)
+        Assert.assertEquals(executeMonitorResponse!!.monitorRunResult.monitorName, monitor.name)
+        Assert.assertEquals(executeMonitorResponse.monitorRunResult.triggerResults.size, 1)
+        searchAlerts(id)
+        val table = Table("asc", "id", null, 1, 0, "")
+        var getAlertsResponse = client()
+            .execute(GetAlertsAction.INSTANCE, GetAlertsRequest(table, "ALL", "ALL", null))
+            .get()
+        Assert.assertTrue(getAlertsResponse != null)
+        Assert.assertTrue(getAlertsResponse.alerts.size == 0)
+        getAlertsResponse = client()
+            .execute(GetAlertsAction.INSTANCE, GetAlertsRequest(table, "ALL", "ALL", id))
+            .get()
+        Assert.assertTrue(getAlertsResponse != null)
+        Assert.assertTrue(getAlertsResponse.alerts.size == 0)
+    }
+
+    fun `test execute pre-existing monitor and update`() {
+        val request = CreateIndexRequest(SCHEDULED_JOBS_INDEX).mapping(ScheduledJobIndices.scheduledJobMappings())
+            .settings(Settings.builder().put("index.hidden", true).build())
+        client().admin().indices().create(request)
+        val monitorStringWithoutName = """
+        {
+        "monitor": {
+        "type": "monitor",
+        "schema_version": 0,
+        "name": "UayEuXpZtb",
+        "monitor_type": "doc_level_monitor",
+        "user": {
+        "name": "",
+        "backend_roles": [],
+        "roles": [],
+        "custom_attribute_names": [],
+        "user_requested_tenant": null
+        },
+        "enabled": true,
+        "enabled_time": 1662753436791,
+        "schedule": {
+        "period": {
+        "interval": 5,
+        "unit": "MINUTES"
+        }
+        },
+        "inputs": [{
+        "doc_level_input": {
+        "description": "description",
+        "indices": [
+        "$index"
+        ],
+        "queries": [{
+        "id": "63efdcce-b5a1-49f4-a25f-6b5f9496a755",
+        "name": "3",
+        "query": "test_field:\"us-west-2\"",
+        "tags": []
+        }]
+        }
+        }],
+        "triggers": [{
+        "document_level_trigger": {
+        "id": "OGnTI4MBv6qt0ATc9Phk",
+        "name": "mrbHRMevYI",
+        "severity": "1",
+        "condition": {
+        "script": {
+        "source": "return true",
+        "lang": "painless"
+        }
+        },
+        "actions": []
+        }
+        }],
+        "last_update_time": 1662753436791
+        }
+        }
+        """.trimIndent()
+        val monitorId = "abc"
+        indexDoc(SCHEDULED_JOBS_INDEX, monitorId, monitorStringWithoutName)
+        val getMonitorResponse = getMonitorResponse(monitorId)
+        Assert.assertNotNull(getMonitorResponse)
+        Assert.assertNotNull(getMonitorResponse.monitor)
+        val monitor = getMonitorResponse.monitor
+
+        val testTime = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(ZonedDateTime.now().truncatedTo(MILLIS))
+        val testDoc = """{
+            "message" : "This is an error from IAD region",
+            "test_strict_date_time" : "$testTime",
+            "test_field" : "us-west-2"
+        }"""
+        indexDoc(index, "1", testDoc)
+        var executeMonitorResponse = executeMonitor(monitor!!, monitorId, false)
+        Assert.assertNotNull(executeMonitorResponse)
+        if (executeMonitorResponse != null) {
+            Assert.assertNotNull(executeMonitorResponse.monitorRunResult.monitorName)
+        }
+        val alerts = searchAlerts(monitorId)
+        assertEquals(alerts.size, 1)
+
+        val updateMonitorResponse = updateMonitor(
+            monitor.copy(id = monitorId),
+            monitorId
+        )
+        Assert.assertNotNull(updateMonitorResponse)
+        indexDoc(index, "2", testDoc)
+        executeMonitorResponse = executeMonitor(updateMonitorResponse!!.monitor, monitorId, false)
+        val table = Table("asc", "id", null, 1, 0, "")
+        var getAlertsResponse = client()
+            .execute(GetAlertsAction.INSTANCE, GetAlertsRequest(table, "ALL", "ALL", null))
+            .get()
+        Assert.assertTrue(getAlertsResponse != null)
+        Assert.assertTrue(getAlertsResponse.alerts.size == 1)
+        getAlertsResponse = client()
+            .execute(GetAlertsAction.INSTANCE, GetAlertsRequest(table, "ALL", "ALL", monitorId))
+            .get()
+        Assert.assertTrue(getAlertsResponse != null)
+        Assert.assertTrue(getAlertsResponse.alerts.size == 1)
+    }
+
+    fun `test get alerts by list of monitors containing both existent and non-existent ids`() {
+        val docQuery = DocLevelQuery(query = "test_field:\"us-west-2\"", name = "3")
+        val docLevelInput = DocLevelMonitorInput("description", listOf(index), listOf(docQuery))
+        val trigger = randomDocumentLevelTrigger(condition = ALWAYS_RUN)
+        var monitor = randomDocumentLevelMonitor(
+            inputs = listOf(docLevelInput),
+            triggers = listOf(trigger),
+        )
+        val monitorResponse = createMonitor(monitor)
+        val testTime = DateTimeFormatter.ISO_OFFSET_DATE_TIME.format(ZonedDateTime.now().truncatedTo(MILLIS))
+        val testDoc = """{
+            "message" : "This is an error from IAD region",
+            "test_strict_date_time" : "$testTime",
+            "test_field" : "us-west-2"
+        }"""
+
+        monitor = monitorResponse!!.monitor
+
+        val id = monitorResponse.id
+
+        var monitor1 = randomDocumentLevelMonitor(
+            inputs = listOf(docLevelInput),
+            triggers = listOf(trigger),
+        )
+        val monitorResponse1 = createMonitor(monitor1)
+        monitor1 = monitorResponse1!!.monitor
+        val id1 = monitorResponse1.id
+        indexDoc(index, "1", testDoc)
+        executeMonitor(monitor1, id1, false)
+        executeMonitor(monitor, id, false)
+        val alerts = searchAlerts(id)
+        assertEquals("Alert saved for test monitor", 1, alerts.size)
+        val alerts1 = searchAlerts(id)
+        assertEquals("Alert saved for test monitor", 1, alerts1.size)
+        val table = Table("asc", "id", null, 1000, 0, "")
+        var getAlertsResponse = client()
+            .execute(
+                GetAlertsAction.INSTANCE,
+                GetAlertsRequest(table, "ALL", "ALL", null)
+            )
+            .get()
+
+        Assert.assertTrue(getAlertsResponse != null)
+        Assert.assertTrue(getAlertsResponse.alerts.size == 2)
+
+        var alertsResponseForRequestWithoutCustomIndex = client()
+            .execute(
+                GetAlertsAction.INSTANCE,
+                GetAlertsRequest(table, "ALL", "ALL", null)
+            )
+            .get()
+        Assert.assertTrue(alertsResponseForRequestWithoutCustomIndex != null)
+        Assert.assertTrue(alertsResponseForRequestWithoutCustomIndex.alerts.size == 2)
+        var getAlertsByAlertIds = client()
+            .execute(
+                GetAlertsAction.INSTANCE,
+                GetAlertsRequest(table, "ALL", "ALL", null)
+            )
+            .get()
+        Assert.assertTrue(getAlertsByAlertIds != null)
+        Assert.assertTrue(getAlertsByAlertIds.alerts.size == 2)
+
+        var getAlertsByWrongAlertIds = client()
+            .execute(
+                GetAlertsAction.INSTANCE,
+                GetAlertsRequest(table, "ALL", "ALL", null)
+            )
+            .get()
+
+        Assert.assertTrue(getAlertsByWrongAlertIds != null)
+    }
+}