github-mirrors/kibana
1
0
Fork 0
mirror of https://github.com/elastic/kibana.git synced 2025-04-24 17:59:23 -04:00
Code Issues Projects Releases Packages Wiki Activity

[Security Solution] Adds serverlessQA tag to the API tests (#180773)

Browse source 
Continues https://github.com/elastic/kibana/pull/179737 effort we are
aligning the tags on Cypress and API to have a unified experience.

## Summary

We want to start integrating our Cypress tests with the serverless
Kibana quality gate. However, not all the teams feel comfortable
enabling all the tests, to facilitate the effort of enabling tests in
the quality gate we are adding the `@serverlessQA` tag, now on API tests
as well.

We use tags to select which tests we want to execute on each environment
and pipeline.

`ess` - runs in ESS env
`serverless` - runs in serverless env and periodic pipeline (failures
don't block release)
`serverlessQA` - runs in kibana release process (failures block release)
`skipInEss` - skipped for ESS env
`skipInServerless` - skipped for all serverless related environments
`skipInServerlessMKI` - skipped for MKI environments

### Description

**Tests tagged as `@serverless`**

All the tests tagged as `@serverless` will be executed as part of the PR
validation process using the serverless FTR environment (not a real
one). That tests will be executed as well as part of the periodic
pipeline using a real serverless project. QA environment is used to do
so using the latest available commit in main at the time of the
execution.

**Tests tagged as `@serverlessQA`**

All the tests tagged as `@serverlessQA` will be executed as part of the
kibana release process using a real serverless project with the latest
image available in the QA environment

**Tests tagged as `@ess`**

All the tests tagged as `@ess` will be executed as part of the PR
validation process using an on-prem ESS environment.

**Tests tagged as `@skipInServerless`**

All the tests tagged as `@skipInServerless` will be excluded from the PR
validation process using the serverless FTR environment, the periodic
pipeline and kibana release process for Serverless.

**Tests tagged as `@skipInEss`**

All the tests tagged as `skipInEss` will be excluded from the PR
validation process using an on-prem ESS environment.

---------

Co-authored-by: Ryland Herrick <ryalnd@gmail.com>
This commit is contained in:
Gloria Hornero 2024-04-23 18:21:13 +02:00 • committed by GitHub
parent bc53c8ae42
commit c351e14e83
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
89 changed files with 630 additions and 188 deletions
Download patch file Download diff file Expand all files Collapse all files

389
.buildkite/pipelines/security_solution/api_integration_serverless_release.yml Normal file
View file

@ -0,0 +1,389 @@
steps:
- group: 'API Integration Serverless Release Tests'
key: test_execution
depends_on: build_image
steps:
- label: Running integration tests for Serverless Exception Workflows
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh exception_workflows:qa:serverless:release
key: exception_workflows:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '*'
limit: 2
- label: Running exception_operators_date_numeric_types:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh exception_operators_date_numeric_types:qa:serverless:release
key: exception_operators_date_numeric_types:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '*'
limit: 2
- label: Running exception_operators_keyword:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh exception_operators_keyword:qa:serverless:release
key: exception_operators_keyword:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '*'
limit: 2
- label: Running exception_operators_ips:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh exception_operators_ips:qa:serverless:release
key: exception_operators_ips:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '*'
limit: 2
- label: Running exception_operators_long:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh exception_operators_long:qa:serverless:release
key: exception_operators_long:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running exception_operators_text:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh exception_operators_text:qa:serverless:release
key: exception_operators_text:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running alerts:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh alerts:qa:serverless:release
key: alerts:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running alerts:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh alerts:essentials:qa:serverless:release
key: alerts:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running actions:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh actions:qa:serverless:release
key: actions:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running genai:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh genai:qa:serverless:release
key: genai:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: "1"
limit: 2
- label: Running rule_execution_logic:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_execution_logic:qa:serverless:release
key: rule_execution_logic:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_patch:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_patch:qa:serverless:release
key: rule_patch:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_patch:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_patch:essentials:qa:serverless:release
key: rule_patch:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_update:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_update:qa:serverless:release
key: rule_update:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_update:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_update:essentials:qa:serverless:release
key: rule_update:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rules_management:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rules_management:essentials:qa:serverless:release
key: rules_management:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running prebuilt_rules_management:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh prebuilt_rules_management:qa:serverless:release
key: prebuilt_rules_management:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running prebuilt_rules_bundled_prebuilt_rules_package:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh prebuilt_rules_bundled_prebuilt_rules_package:qa:serverless:release
key: prebuilt_rules_bundled_prebuilt_rules_package:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running prebuilt_rules_large_prebuilt_rules_package:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh prebuilt_rules_large_prebuilt_rules_package:qa:serverless:release
key: prebuilt_rules_large_prebuilt_rules_package:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running prebuilt_rules_update_prebuilt_rules_package:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh prebuilt_rules_update_prebuilt_rules_package:qa:serverless:release
key: prebuilt_rules_update_prebuilt_rules_package:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_bulk_actions:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_bulk_actions:qa:serverless:release
key: rule_bulk_actions:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_read:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_read:qa:serverless:release
key: rule_read:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_import_export:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_import_export:essentials:qa:serverless:release
key: rule_import_export:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_import_export:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_import_export:qa:serverless:release
key: rule_import_export:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_management:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_management:qa:serverless:release
key: rule_management:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_read:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_read:essentials:qa:serverless:release
key: rule_read:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_creation:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_creation:qa:serverless:release
key: rule_creation:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_creation:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_creation:essentials:qa:serverless:release
key: rule_creation:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_delete:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_delete:qa:serverless:release
key: rule_delete:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running rule_delete:essentials:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh rule_delete:essentials:qa:serverless:release
key: rule_delete:essentials:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running exception_lists_items:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh exception_lists_items:qa:serverless:release
key: exception_lists_items:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running lists_items:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh lists_items:qa:serverless:release
key: lists_items:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running user_roles:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh user_roles:qa:serverless:release
key: user_roles:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running telemetry:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh telemetry:qa:serverless:release
key: telemetry:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2
- label: Running entity_analytics:qa:serverless:release
command: .buildkite/scripts/pipelines/security_solution_quality_gate/api_integration/api-integration-tests.sh entity_analytics:qa:serverless:release
key: entity_analytics:qa:serverless:release
agents:
queue: n2-4-spot
timeout_in_minutes: 120
retry:
automatic:
- exit_status: '1'
limit: 2

20
x-pack/test/security_solution_api_integration/README.md
View file

@ -15,16 +15,28 @@ we have introduced the `detection_response` directory to consolidate all the int
- In this directory, Mocha tagging is utilized to assign tags to specific test suites and individual test cases. This tagging system enables the ability to selectively apply tags to test suites and test cases, facilitating the exclusion of specific test cases within a test suite as needed.
- There are three primary tags that have been defined: @ess, @serverless, and @brokenInServerless
- Test suites and cases are prefixed with specific tags to determine their execution in particular environments or to exclude them from specific environments.
- We are using the following tags:
* `@ess`: Runs in an ESS environment (on-prem installation) as part of the CI validation on PRs.
* `@serverless`: Runs in the first quality gate and in the periodic pipeline.
* `@serverlessQA`: Runs in the second quality gate.
* `@skipInEss`: Skipped for ESS environment.
* `@skipInServerless`: Skipped for all quality gates, CI and periodic pipeline.
* `@skipInServerlessMKI`: Skipped for all the MKI environments.
ex:
```
describe('@serverless @ess create_rules', () => { ==> tests in this suite will run in both Ess and Serverless
describe('creating rules', () => {});
describe('@brokenInServerless missing timestamps', () => {}); ==> tests in this suite will be excluded in Serverless
// This test is skipped due to flakiness in serverless environments: https://github.com/elastic/kibana/issues/497777
describe('@skipInServerless missing timestamps', () => {}); ==> tests in this suite will be excluded in Serverless
```
@ -86,7 +98,7 @@ In this project, you can run various commands to execute tests and workflows, ea
```
3. **Run tests for "exception_workflows" using the serverless runner in the "qaEnv" environment:**
```shell
npm run run-tests:dr:default exceptions/workflows serverless qaEnv
npm run run-tests:dr:default exceptions/workflows serverless qaPeriodicEnv
```
4. **Run the server for "exception_workflows" in the "essEnv" environment:**
```shell

2
x-pack/test/security_solution_api_integration/config/ess/config.base.ts
View file

@ -96,7 +96,7 @@ export function createTestConfig(options: CreateTestConfigOptions, testFiles?: s
],
},
mochaOpts: {
grep: '/^(?!.*@brokenInEss).*@ess.*/',
grep: '/^(?!.*@skipInEss).*@ess.*/',
},
};
};

2
x-pack/test/security_solution_api_integration/config/serverless/config.base.essentials.ts
View file

@ -44,7 +44,7 @@ export function createTestConfig(options: CreateTestConfigOptions) {
mochaOpts: {
...svlSharedConfig.get('mochaOpts'),
grep: '/^(?!.*@brokenInServerless).*@serverless.*/',
grep: '/^(?!.*@skipInServerless).*@serverless.*/',
},
};
};

2
x-pack/test/security_solution_api_integration/config/serverless/config.base.ts
View file

@ -42,7 +42,7 @@ export function createTestConfig(options: CreateTestConfigOptions) {
mochaOpts: {
...svlSharedConfig.get('mochaOpts'),
grep: '/^(?!.*@brokenInServerless).*@serverless.*/',
grep: '/^(?!.*@skipInServerless).*@serverless.*/',
},
};
};

114
x-pack/test/security_solution_api_integration/package.json
View file

@ -37,225 +37,263 @@
"genai:server:serverless": "npm run initialize-server:genai:trial_complete invoke_ai serverless",
"genai:runner:serverless": "npm run run-tests:genai:trial_complete invoke_ai serverless serverlessEnv",
"genai:qa:serverless": "npm run run-tests:genai:trial_complete invoke_ai serverless qaEnv",
"genai:qa:serverless": "npm run run-tests:genai:trial_complete invoke_ai serverless qaPeriodicEnv",
"genai:qa:serverless:release": "npm run run-tests:genai:trial_complete invoke_ai serverlessQA qaEnv",
"genai:server:ess": "npm run initialize-server:genai:trial_complete invoke_ai ess",
"genai:runner:ess": "npm run run-tests:genai:trial_complete invoke_ai ess essEnv",
"nlp_cleanup_task:complete:server:serverless": "npm run initialize-server:genai:trial_complete nlp_cleanup_task serverless",
"nlp_cleanup_task:complete:runner:serverless": "npm run run-tests:genai:trial_complete nlp_cleanup_task serverless serverlessEnv",
"nlp_cleanup_task:complete:qa:serverless": "npm run run-tests:genai:trial_complete nlp_cleanup_task serverless qaEnv",
"nlp_cleanup_task:complete:qa:serverless": "npm run run-tests:genai:trial_complete nlp_cleanup_task serverless qaPeriodicEnv",
"nlp_cleanup_task:complete:qa:serverless:release": "npm run run-tests:genai:trial_complete nlp_cleanup_task serverlessQA qaEnv",
"nlp_cleanup_task:essentials:server:serverless": "npm run initialize-server:genai:basic_essentials nlp_cleanup_task serverless",
"nlp_cleanup_task:essentials:runner:serverless": "npm run run-tests:genai:basic_essentials nlp_cleanup_task serverless serverlessEnv",
"nlp_cleanup_task:essentials:qa:serverless": "npm run run-tests:genai:basic_essentials nlp_cleanup_task serverless qaEnv",
"nlp_cleanup_task:essentials:qa:serverless": "npm run run-tests:genai:basic_essentials nlp_cleanup_task serverless qaPeriodicEnv",
"nlp_cleanup_task:essentials:qa:serverless:release": "npm run run-tests:genai:basic_essentials nlp_cleanup_task serverlessQA qaEnv",
"entity_analytics:server:serverless": "npm run initialize-server:ea:trial_complete risk_engine serverless",
"entity_analytics:runner:serverless": "npm run run-tests:ea:trial_complete risk_engine serverless serverlessEnv",
"entity_analytics:qa:serverless": "npm run run-tests:ea:trial_complete risk_engine serverless qaEnv",
"entity_analytics:qa:serverless": "npm run run-tests:ea:trial_complete risk_engine serverless qaPeriodicEnv",
"entity_analytics:qa:serverless:release": "npm run run-tests:ea:trial_complete risk_engine serverlessQA qaEnv",
"entity_analytics:server:ess": "npm run initialize-server:ea:trial_complete risk_engine ess",
"entity_analytics:runner:ess": "npm run run-tests:ea:trial_complete risk_engine ess essEnv",
"entity_analytics:essentials:server:serverless": "npm run initialize-server:ea:basic_essentials risk_engine serverless",
"entity_analytics:essentials:runner:serverless": "npm run run-tests:ea:basic_essentials risk_engine serverless serverlessEnv",
"entity_analytics:essentials:qa:serverless": "npm run run-tests:ea:basic_essentials risk_engine serverless qaEnv",
"entity_analytics:essentials:qa:serverless": "npm run run-tests:ea:basic_essentials risk_engine serverless qaPeriodicEnv",
"entity_analytics:essentials:qa:serverless:release": "npm run run-tests:ea:basic_essentials risk_engine serverlessQA qaEnv",
"entity_analytics:essentials:server:ess": "npm run initialize-server:ea:basic_essentials risk_engine ess",
"entity_analytics:essentials:runner:ess": "npm run run-tests:ea:basic_essentials risk_engine ess essEnv",
"exception_lists_items:server:serverless": "npm run initialize-server:lists:complete exception_lists_items serverless",
"exception_lists_items:runner:serverless": "npm run run-tests:lists:complete exception_lists_items serverless serverlessEnv",
"exception_lists_items:qa:serverless": "npm run run-tests:lists:complete exception_lists_items serverless qaEnv",
"exception_lists_items:qa:serverless": "npm run run-tests:lists:complete exception_lists_items serverless qaPeriodicEnv",
"exception_lists_items:qa:serverless:release": "npm run run-tests:lists:complete exception_lists_items serverlessQA qaEnv",
"exception_lists_items:server:ess": "npm run initialize-server:lists:complete exception_lists_items ess",
"exception_lists_items:runner:ess": "npm run run-tests:lists:complete exception_lists_items ess essEnv",
"lists_items:server:serverless": "npm run initialize-server:lists:complete lists_items serverless",
"lists_items:runner:serverless": "npm run run-tests:lists:complete lists_items serverless serverlessEnv",
"lists_items:qa:serverless": "npm run run-tests:lists:complete lists_items serverless qaEnv",
"lists_items:qa:serverless": "npm run run-tests:lists:complete lists_items serverless qaPeriodicEnv",
"lists_items:qa:serverless:release": "npm run run-tests:lists:complete lists_items serverlessQA qaEnv",
"lists_items:server:ess": "npm run initialize-server:lists:complete lists_items ess",
"lists_items:runner:ess": "npm run run-tests:lists:complete lists_items ess essEnv",
"user_roles:server:serverless": "npm run initialize-server:dr user_roles serverless",
"user_roles:runner:serverless": "npm run run-tests:dr user_roles serverless serverlessEnv",
"user_roles:qa:serverless": "npm run run-tests:dr user_roles serverless qaEnv",
"user_roles:qa:serverless": "npm run run-tests:dr user_roles serverless qaPeriodicEnv",
"user_roles:qa:serverless:release": "npm run run-tests:dr user_roles serverlessQA qaEnv",
"user_roles:server:ess": "npm run initialize-server:dr user_roles ess",
"user_roles:runner:ess": "npm run run-tests:dr user_roles ess essEnv",
"telemetry:server:serverless": "npm run initialize-server:dr telemetry serverless",
"telemetry:runner:serverless": "npm run run-tests:dr telemetry serverless serverlessEnv",
"telemetry:qa:serverless": "npm run run-tests:dr telemetry serverless qaEnv",
"telemetry:qa:serverless": "npm run run-tests:dr telemetry serverless qaPeriodicEnv",
"telemetry:qa:serverless:release": "npm run run-tests:dr telemetry serverlessQA qaEnv",
"telemetry:server:ess": "npm run initialize-server:dr telemetry ess",
"telemetry:runner:ess": "npm run run-tests:dr telemetry ess essEnv",
"exception_workflows:essentials:server:serverless": "npm run initialize-server:de:basic_essentials exceptions/workflows serverless",
"exception_workflows:essentials:runner:serverless": "npm run run-tests:de:basic_essentials exceptions/workflows serverless serverlessEnv",
"exception_workflows:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/workflows serverless qaEnv",
"exception_workflows:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/workflows serverless qaPeriodicEnv",
"exception_workflows:essentials:qa:serverless:release": "npm run run-tests:de:basic_essentials exceptions/workflows serverlessQA qaEnv",
"exception_workflows:basic:server:ess": "npm run initialize-server:de:basic_essentials exceptions/workflows ess",
"exception_workflows:basic:runner:ess": "npm run run-tests:de:basic_essentials exceptions/workflows ess essEnv",
"exception_operators_date_numeric_types:essentials:server:serverless": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/date_numeric_types serverless",
"exception_operators_date_numeric_types:essentials:runner:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/date_numeric_types serverless serverlessEnv",
"exception_operators_date_numeric_types:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/date_numeric_types serverless qaEnv",
"exception_operators_date_numeric_types:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/date_numeric_types serverless qaPeriodicEnv",
"exception_operators_date_numeric_types:essentials:qa:serverless:release": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/date_numeric_types serverlessQA qaEnv",
"exception_operators_date_numeric_types:basic:server:ess": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/date_numeric_types ess",
"exception_operators_date_numeric_types:basic:runner:ess": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/date_numeric_types ess essEnv",
"exception_operators_keyword:essentials:server:serverless": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/keyword serverless",
"exception_operators_keyword:essentials:runner:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/keyword serverless serverlessEnv",
"exception_operators_keyword:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/keyword serverless qaEnv",
"exception_operators_keyword:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/keyword serverless qaPeriodicEnv",
"exception_operators_keyword:essentials:qa:serverless:release": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/keyword serverlessQA qaEnv",
"exception_operators_keyword:basic:server:ess": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/keyword ess",
"exception_operators_keyword:basic:runner:ess": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/keyword ess essEnv",
"exception_operators_ips:essentials:server:serverless": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/ips serverless",
"exception_operators_ips:essentials:runner:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/ips serverless serverlessEnv",
"exception_operators_ips:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/ips serverless qaEnv",
"exception_operators_ips:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/ips serverless qaPeriodicEnv",
"exception_operators_ips:essentials:qa:serverless:release": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/ips serverlessQA qaEnv",
"exception_operators_ips:basic:server:ess": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/ips ess",
"exception_operators_ips:basic:runner:ess": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/ips ess essEnv",
"exception_operators_long:essentials:server:serverless": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/long serverless",
"exception_operators_long:essentials:runner:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/long serverless serverlessEnv",
"exception_operators_long:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/long serverless qaEnv",
"exception_operators_long:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/long serverless qaPeriodicEnv",
"exception_operators_long:essentials:qa:serverless:release": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/long serverlessQA qaEnv",
"exception_operators_long:basic:server:ess": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/long ess",
"exception_operators_long:basic:runner:ess": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/long ess essEnv",
"exception_operators_text:essentials:server:serverless": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/text serverless",
"exception_operators_text:essentials:runner:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/text serverless serverlessEnv",
"exception_operators_text:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/text serverless qaEnv",
"exception_operators_text:essentials:qa:serverless": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/text serverless qaPeriodicEnv",
"exception_operators_text:essentials:qa:serverless:release": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/text serverlessQA qaEnv",
"exception_operators_text:basic:server:ess": "npm run initialize-server:de:basic_essentials exceptions/operators_data_types/text ess",
"exception_operators_text:basic:runner:ess": "npm run run-tests:de:basic_essentials exceptions/operators_data_types/text ess essEnv",
"actions:server:serverless": "npm run initialize-server:de actions serverless",
"actions:runner:serverless": "npm run run-tests:de actions serverless serverlessEnv",
"actions:qa:serverless": "npm run run-tests:de actions serverless qaEnv",
"actions:qa:serverless": "npm run run-tests:de actions serverless qaPeriodicEnv",
"actions:qa:serverless:release": "npm run run-tests:de actions serverlessQA qaEnv",
"actions:server:ess": "npm run initialize-server:de actions ess",
"actions:runner:ess": "npm run run-tests:de actions ess essEnv",
"alerts:server:serverless": "npm run initialize-server:de alerts serverless",
"alerts:runner:serverless": "npm run run-tests:de alerts serverless serverlessEnv",
"alerts:qa:serverless": "npm run run-tests:de alerts serverless qaEnv",
"alerts:qa:serverless": "npm run run-tests:de alerts serverless qaPeriodicEnv",
"alerts:qa:serverless:release": "npm run run-tests:de alerts serverlessQA qaEnv",
"alerts:server:ess": "npm run initialize-server:de alerts ess",
"alerts:runner:ess": "npm run run-tests:de alerts ess essEnv",
"alerts:essentials:server:serverless": "npm run initialize-server:de:basic_essentials alerts serverless",
"alerts:essentials:runner:serverless": "npm run run-tests:de:basic_essentials alerts serverless serverlessEnv",
"alerts:essentials:qa:serverless": "npm run run-tests:de:basic_essentials alerts serverless qaEnv",
"alerts:essentials:qa:serverless": "npm run run-tests:de:basic_essentials alerts serverless qaPeriodicEnv",
"alerts:essentials:qa:serverless:release": "npm run run-tests:de:basic_essentials alerts serverlessQA qaEnv",
"alerts:basic:server:ess": "npm run initialize-server:de:basic_essentials alerts ess",
"alerts:basic:runner:ess": "npm run run-tests:de:basic_essentials alerts ess essEnv",
"rule_execution_logic:server:serverless": "npm run initialize-server:de rule_execution_logic serverless",
"rule_execution_logic:runner:serverless": "npm run run-tests:de rule_execution_logic serverless serverlessEnv",
"rule_execution_logic:qa:serverless": "npm run run-tests:de rule_execution_logic serverless qaEnv",
"rule_execution_logic:qa:serverless": "npm run run-tests:de rule_execution_logic serverless qaPeriodicEnv",
"rule_execution_logic:qa:serverless:release": "npm run run-tests:de rule_execution_logic serverlessQA qaEnv",
"rule_execution_logic:server:ess": "npm run initialize-server:de rule_execution_logic ess",
"rule_execution_logic:runner:ess": "npm run run-tests:de rule_execution_logic ess essEnv",
"rule_creation:server:serverless": "npm run initialize-server:rm rule_creation serverless",
"rule_creation:runner:serverless": "npm run run-tests:rm rule_creation serverless serverlessEnv",
"rule_creation:qa:serverless": "npm run run-tests:rm rule_creation serverless qaEnv",
"rule_creation:qa:serverless": "npm run run-tests:rm rule_creation serverless qaPeriodicEnv",
"rule_creation:qa:serverless:release": "npm run run-tests:rm rule_creation serverlessQA qaEnv",
"rule_creation:server:ess": "npm run initialize-server:rm rule_creation ess",
"rule_creation:runner:ess": "npm run run-tests:rm rule_creation ess essEnv",
"rule_creation:essentials:server:serverless": "npm run initialize-server:rm:basic_essentials rule_creation serverless",
"rule_creation:essentials:runner:serverless": "npm run run-tests:rm:basic_essentials rule_creation serverless serverlessEnv",
"rule_creation:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_creation serverless qaEnv",
"rule_creation:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_creation serverless qaPeriodicEnv",
"rule_creation:essentials:qa:serverless:release": "npm run run-tests:rm:basic_essentials rule_creation serverlessQA qaEnv",
"rule_creation:basic:server:ess": "npm run initialize-server:rm:basic_essentials rule_creation ess",
"rule_creation:basic:runner:ess": "npm run run-tests:rm:basic_essentials rule_creation ess essEnv",
"rule_update:server:serverless": "npm run initialize-server:rm rule_update serverless",
"rule_update:runner:serverless": "npm run run-tests:rm rule_update serverless serverlessEnv",
"rule_update:qa:serverless": "npm run run-tests:rm rule_update serverless qaEnv",
"rule_update:qa:serverless": "npm run run-tests:rm rule_update serverless qaPeriodicEnv",
"rule_update:qa:serverless:release": "npm run run-tests:rm rule_update serverlessQA qaEnv",
"rule_update:server:ess": "npm run initialize-server:rm rule_update ess",
"rule_update:runner:ess": "npm run run-tests:rm rule_update ess essEnv",
"rule_update:essentials:server:serverless": "npm run initialize-server:rm:basic_essentials rule_update serverless",
"rule_update:essentials:runner:serverless": "npm run run-tests:rm:basic_essentials rule_update serverless serverlessEnv",
"rule_update:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_update serverless qaEnv",
"rule_update:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_update serverless qaPeriodicEnv",
"rule_update:essentials:qa:serverless:release": "npm run run-tests:rm:basic_essentials rule_update serverlessQA qaEnv",
"rule_update:basic:server:ess": "npm run initialize-server:rm:basic_essentials rule_update ess",
"rule_update:basic:runner:ess": "npm run run-tests:rm:basic_essentials rule_update ess essEnv",
"rule_patch:server:serverless": "npm run initialize-server:rm rule_patch serverless",
"rule_patch:runner:serverless": "npm run run-tests:rm rule_patch serverless serverlessEnv",
"rule_patch:qa:serverless": "npm run run-tests:rm rule_patch serverless qaEnv",
"rule_patch:qa:serverless": "npm run run-tests:rm rule_patch serverless qaPeriodicEnv",
"rule_patch:qa:serverless:release": "npm run run-tests:rm rule_patch serverlessQA qaEnv",
"rule_patch:server:ess": "npm run initialize-server:rm rule_patch ess",
"rule_patch:runner:ess": "npm run run-tests:rm rule_patch ess essEnv",
"rule_patch:essentials:server:serverless": "npm run initialize-server:rm:basic_essentials rule_patch serverless",
"rule_patch:essentials:runner:serverless": "npm run run-tests:rm:basic_essentials rule_patch serverless serverlessEnv",
"rule_patch:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_patch serverless qaEnv",
"rule_patch:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_patch serverless qaPeriodicEnv",
"rule_patch:essentials:qa:serverless:release": "npm run run-tests:rm:basic_essentials rule_patch serverlessQA qaEnv",
"rule_patch:basic:server:ess": "npm run initialize-server:rm:basic_essentials rule_patch ess",
"rule_patch:basic:runner:ess": "npm run run-tests:rm:basic_essentials rule_patch ess essEnv",
"prebuilt_rules_management:server:serverless": "npm run initialize-server:rm prebuilt_rules/management serverless",
"prebuilt_rules_management:runner:serverless": "npm run run-tests:rm prebuilt_rules/management serverless serverlessEnv",
"prebuilt_rules_management:qa:serverless": "npm run run-tests:rm prebuilt_rules/management serverless qaEnv",
"prebuilt_rules_management:qa:serverless": "npm run run-tests:rm prebuilt_rules/management serverless qaPeriodicEnv",
"prebuilt_rules_management:qa:serverless:release": "npm run run-tests:rm prebuilt_rules/management serverlessQA qaEnv",
"prebuilt_rules_management:server:ess": "npm run initialize-server:rm prebuilt_rules/management ess",
"prebuilt_rules_management:runner:ess": "npm run run-tests:rm prebuilt_rules/management ess essEnv",
"prebuilt_rules_bundled_prebuilt_rules_package:server:serverless": "npm run initialize-server:rm prebuilt_rules/bundled_prebuilt_rules_package serverless",
"prebuilt_rules_bundled_prebuilt_rules_package:runner:serverless": "npm run run-tests:rm prebuilt_rules/bundled_prebuilt_rules_package serverless serverlessEnv",
"prebuilt_rules_bundled_prebuilt_rules_package:qa:serverless": "npm run run-tests:rm prebuilt_rules/bundled_prebuilt_rules_package serverless qaEnv",
"prebuilt_rules_bundled_prebuilt_rules_package:qa:serverless": "npm run run-tests:rm prebuilt_rules/bundled_prebuilt_rules_package serverless qaPeriodicEnv",
"prebuilt_rules_bundled_prebuilt_rules_package:qa:serverless:release": "npm run run-tests:rm prebuilt_rules/bundled_prebuilt_rules_package serverlessQA qaEnv",
"prebuilt_rules_bundled_prebuilt_rules_package:server:ess": "npm run initialize-server:rm prebuilt_rules/bundled_prebuilt_rules_package ess",
"prebuilt_rules_bundled_prebuilt_rules_package:runner:ess": "npm run run-tests:rm prebuilt_rules/bundled_prebuilt_rules_package ess essEnv",
"prebuilt_rules_large_prebuilt_rules_package:server:serverless": "npm run initialize-server:rm prebuilt_rules/large_prebuilt_rules_package serverless",
"prebuilt_rules_large_prebuilt_rules_package:runner:serverless": "npm run run-tests:rm prebuilt_rules/large_prebuilt_rules_package serverless serverlessEnv",
"prebuilt_rules_large_prebuilt_rules_package:qa:serverless": "npm run run-tests:rm prebuilt_rules/large_prebuilt_rules_package serverless qaEnv",
"prebuilt_rules_large_prebuilt_rules_package:qa:serverless": "npm run run-tests:rm prebuilt_rules/large_prebuilt_rules_package serverless qaPeriodicEnv",
"prebuilt_rules_large_prebuilt_rules_package:qa:serverles:release": "npm run run-tests:rm prebuilt_rules/large_prebuilt_rules_package serverlessQA qaEnv",
"prebuilt_rules_large_prebuilt_rules_package:server:ess": "npm run initialize-server:rm prebuilt_rules/large_prebuilt_rules_package ess",
"prebuilt_rules_large_prebuilt_rules_package:runner:ess": "npm run run-tests:rm prebuilt_rules/large_prebuilt_rules_package ess essEnv",
"prebuilt_rules_update_prebuilt_rules_package:server:serverless": "npm run initialize-server:rm prebuilt_rules/update_prebuilt_rules_package serverless",
"prebuilt_rules_update_prebuilt_rules_package:runner:serverless": "npm run run-tests:rm prebuilt_rules/update_prebuilt_rules_package serverless serverlessEnv",
"prebuilt_rules_update_prebuilt_rules_package:qa:serverless": "npm run run-tests:rm prebuilt_rules/update_prebuilt_rules_package serverless qaEnv",
"prebuilt_rules_update_prebuilt_rules_package:qa:serverless": "npm run run-tests:rm prebuilt_rules/update_prebuilt_rules_package serverless qaPeriodicEnv",
"prebuilt_rules_update_prebuilt_rules_package:qa:serverless:release": "npm run run-tests:rm prebuilt_rules/update_prebuilt_rules_package serverlessQA qaEnv",
"prebuilt_rules_update_prebuilt_rules_package:server:ess": "npm run initialize-server:rm prebuilt_rules/update_prebuilt_rules_package ess",
"prebuilt_rules_update_prebuilt_rules_package:runner:ess": "npm run run-tests:rm prebuilt_rules/update_prebuilt_rules_package ess essEnv",
"rule_delete:server:serverless": "npm run initialize-server:rm rule_delete serverless",
"rule_delete:runner:serverless": "npm run run-tests:rm rule_delete serverless serverlessEnv",
"rule_delete:qa:serverless": "npm run run-tests:rm rule_delete serverless qaEnv",
"rule_delete:qa:serverless": "npm run run-tests:rm rule_delete serverless qaPeriodicEnv",
"rule_delete:qa:serverless:release": "npm run run-tests:rm rule_delete serverlessQA qaEnv",
"rule_delete:server:ess": "npm run initialize-server:rm rule_delete ess",
"rule_delete:runner:ess": "npm run run-tests:rm rule_delete ess essEnv",
"rule_delete:essentials:server:serverless": "npm run initialize-server:rm:basic_essentials rule_delete serverless",
"rule_delete:essentials:runner:serverless": "npm run run-tests:rm:basic_essentials rule_delete serverless serverlessEnv",
"rule_delete:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_delete serverless qaEnv",
"rule_delete:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_delete serverless qaPeriodicEnv",
"rule_delete:essentials:qa:serverless:release": "npm run run-tests:rm:basic_essentials rule_delete serverlessQA qaEnv",
"rule_delete:basic:server:ess": "npm run initialize-server:rm:basic_essentials rule_delete ess",
"rule_delete:basic:runner:ess": "npm run run-tests:rm:basic_essentials rule_delete ess essEnv",
"rule_import_export:server:serverless": "npm run initialize-server:rm rule_import_export serverless",
"rule_import_export:runner:serverless": "npm run run-tests:rm rule_import_export serverless serverlessEnv",
"rule_import_export:qa:serverless": "npm run run-tests:rm rule_import_export serverless qaEnv",
"rule_import_export:qa:serverless": "npm run run-tests:rm rule_import_export serverless qaPeriodicEnv",
"rule_import_export:qa:serverless:release": "npm run run-tests:rm rule_import_export serverlessQA qaEnv",
"rule_import_export:server:ess": "npm run initialize-server:rm rule_import_export ess",
"rule_import_export:runner:ess": "npm run run-tests:rm rule_import_export ess essEnv",
"rule_import_export:essentials:server:serverless": "npm run initialize-server:rm:basic_essentials rule_import_export serverless",
"rule_import_export:essentials:runner:serverless": "npm run run-tests:rm:basic_essentials rule_import_export serverless serverlessEnv",
"rule_import_export:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_import_export serverless qaEnv",
"rule_import_export:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_import_export serverless qaPeriodicEnv",
"rule_import_export:essentials:qa:serverless:release": "npm run run-tests:rm:basic_essentials rule_import_export serverlessQA qaEnv",
"rule_import_export:basic:server:ess": "npm run initialize-server:rm:basic_essentials rule_import_export ess",
"rule_import_export:basic:runner:ess": "npm run run-tests:rm:basic_essentials rule_import_export ess essEnv",
"rule_management:server:serverless": "npm run initialize-server:rm rule_management serverless",
"rule_management:runner:serverless": "npm run run-tests:rm rule_management serverless serverlessEnv",
"rule_management:qa:serverless": "npm run run-tests:rm rule_management serverless qaEnv",
"rule_management:qa:serverless": "npm run run-tests:rm rule_management serverless qaPeriodicEnv",
"rule_management:qa:serverless:release": "npm run run-tests:rm rule_management serverlessQA qaEnv",
"rule_management:server:ess": "npm run initialize-server:rm rule_management ess",
"rule_management:runner:ess": "npm run run-tests:rm rule_management ess essEnv",
"rule_bulk_actions:server:serverless": "npm run initialize-server:rm rule_bulk_actions serverless",
"rule_bulk_actions:runner:serverless": "npm run run-tests:rm rule_bulk_actions serverless serverlessEnv",
"rule_bulk_actions:qa:serverless": "npm run run-tests:rm rule_bulk_actions serverless qaEnv",
"rule_bulk_actions:qa:serverless": "npm run run-tests:rm rule_bulk_actions serverless qaPeriodicEnv",
"rule_bulk_actions:qa:serverless:release": "npm run run-tests:rm rule_bulk_actions serverlessQA qaEnv",
"rule_bulk_actions:server:ess": "npm run initialize-server:rm rule_bulk_actions ess",
"rule_bulk_actions:runner:ess": "npm run run-tests:rm rule_bulk_actions ess essEnv",
"rule_read:server:serverless": "npm run initialize-server:rm rule_read serverless",
"rule_read:runner:serverless": "npm run run-tests:rm rule_read serverless serverlessEnv",
"rule_read:qa:serverless": "npm run run-tests:rm rule_read serverless qaEnv",
"rule_read:qa:serverless": "npm run run-tests:rm rule_read serverless qaPeriodicEnv",
"rule_read:qa:serverless:release": "npm run run-tests:rm rule_read serverlessQA qaEnv",
"rule_read:server:ess": "npm run initialize-server:rm rule_read ess",
"rule_read:runner:ess": "npm run run-tests:rm rule_read ess essEnv",
"rule_read:essentials:server:serverless": "npm run initialize-server:rm:basic_essentials rule_read serverless",
"rule_read:essentials:runner:serverless": "npm run run-tests:rm:basic_essentials rule_read serverless serverlessEnv",
"rule_read:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_read serverless qaEnv",
"rule_read:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_read serverless qaPeriodicEnv",
"rule_read:essentials:qa:serverless:release": "npm run run-tests:rm:basic_essentials rule_read serverlessQA qaEnv",
"rule_read:basic:server:ess": "npm run initialize-server:rm:basic_essentials rule_read ess",
"rule_read:basic:runner:ess": "npm run run-tests:rm:basic_essentials rule_read ess essEnv",
"rules_management:essentials:server:serverless": "npm run initialize-server:rm:basic_essentials rule_management serverless",
"rules_management:essentials:runner:serverless": "npm run run-tests:rm:basic_essentials rule_management serverless serverlessEnv",
"rules_management:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_management serverless qaEnv",
"rules_management:essentials:qa:serverless": "npm run run-tests:rm:basic_essentials rule_management serverless qaPeriodicEnv",
"rules_management:essentials:qa:serverless:release": "npm run run-tests:rm:basic_essentials rule_management serverlessQA qaEnv",
"rules_management:basic:server:ess": "npm run initialize-server:rm:basic_essentials rule_management ess",
"rules_management:basic:runner:ess": "npm run run-tests:rm:basic_essentials rule_management ess essEnv"
}

10
x-pack/test/security_solution_api_integration/scripts/index.js
View file

@ -21,15 +21,19 @@ let grepArgs = [];
if (type !== 'server') {
switch (environment) {
case 'serverlessEnv':
grepArgs = ['--grep', '/^(?!.*@brokenInServerless).*@serverless.*/'];
grepArgs = ['--grep', '/^(?!.*@skipInServerless).*@serverless.*/'];
break;
case 'essEnv':
grepArgs = ['--grep', '/^(?!.*@brokenInEss).*@ess.*/'];
grepArgs = ['--grep', '/^(?!.*@skipInEss).*@ess.*/'];
break;
case 'qaPeriodicEnv':
grepArgs = ['--grep', '/^(?!.*@skipInServerless|.*@skipInServerlessMKI).*@serverless.*/'];
break;
case 'qaEnv':
grepArgs = ['--grep', '/^(?!.*@brokenInServerless|.*@skipInQA).*@serverless.*/'];
grepArgs = ['--grep', '/^(?!.*@skipInServerless|.*@skipInServerlessMKI).*@serverlessQA.*/'];
break;
default:

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/actions/trial_license_complete_tier/add_actions.ts
View file

@ -21,7 +21,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess add_actions', () => {
describe('@serverless @serverlessQA @ess add_actions', () => {
describe('adding actions', () => {
beforeEach(async () => {
await es.indices.delete({ index: 'logs-test', ignore_unavailable: true });

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/actions/trial_license_complete_tier/check_privileges.ts
View file

@ -31,7 +31,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@ess @serverless @brokenInServerless check_privileges', () => {
describe('@ess @serverless @skipInServerless check_privileges', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/auditbeat/hosts');
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/alias');

12
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/actions/trial_license_complete_tier/update_actions.ts
View file

@ -147,7 +147,8 @@ export default ({ getService }: FtrProviderContext) => {
expect(body?.execution_summary?.last_execution?.status).toBe('succeeded');
});
it('@skipInQA expects an updated rule with a webhook action and meta field runs successfully', async () => {
// Broken in MKI environment, needs triage
it('@skipInServerlessMKI expects an updated rule with a webhook action and meta field runs successfully', async () => {
const webhookAction = await createWebHookRuleAction(supertest);
await supertest
@ -187,7 +188,8 @@ export default ({ getService }: FtrProviderContext) => {
expect(body?.execution_summary?.last_execution?.status).toBe('succeeded');
});
it('@skipInQA adds a webhook to an immutable rule', async () => {
// Broken in MKI environment, needs triage
it('@skipInServerlessMKI adds a webhook to an immutable rule', async () => {
const immutableRule = await getImmutableRule();
const webhookAction = await createWebHookRuleAction(supertest);
const ruleAction = {
@ -210,7 +212,8 @@ export default ({ getService }: FtrProviderContext) => {
expect(updatedRule.throttle).toEqual(immutableRule.throttle);
});
it('@skipInQA should be able to create a new webhook action, attach it to an immutable rule and the count of prepackaged rules should not increase. If this fails, suspect the immutable tags are not staying on the rule correctly.', async () => {
// Broken in MKI environment, needs triage
it('@skipInServerlessMKI should be able to create a new webhook action, attach it to an immutable rule and the count of prepackaged rules should not increase. If this fails, suspect the immutable tags are not staying on the rule correctly.', async () => {
const immutableRule = await getImmutableRule();
const hookAction = await createWebHookRuleAction(supertest);
const ruleToUpdate = getRuleWithWebHookAction(
@ -224,7 +227,8 @@ export default ({ getService }: FtrProviderContext) => {
expect(status.rules_not_installed).toBe(0);
});
it('@skipInQA should be able to create a new webhook action, attach it to an immutable rule and the rule should stay immutable when searching against immutable tags', async () => {
// Broken in MKI environment, needs triage
it('@skipInServerlessMKI should be able to create a new webhook action, attach it to an immutable rule and the rule should stay immutable when searching against immutable tags', async () => {
const immutableRule = await getImmutableRule();
const webhookAction = await createWebHookRuleAction(supertest);
const ruleAction = {

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/alerts/basic_license_essentials_tier/field_aliases.ts
View file

@ -29,7 +29,7 @@ export default ({ getService }: FtrProviderContext) => {
name: string;
}
describe('@ess @serverless Tests involving aliases of source indexes and the alerts index', () => {
describe('@ess @serverless @serverlessQA Tests involving aliases of source indexes and the alerts index', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/alias');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/alerts/basic_license_essentials_tier/query_alerts.ts
View file

@ -34,7 +34,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@ess @serverless query_signals_route and find_alerts_route', () => {
describe('@ess @serverless @serverlessQA query_signals_route and find_alerts_route', () => {
describe('validation checks', () => {
it('should not give errors when querying and the alerts index does exist and is empty', async () => {
await createAlertsIndex(supertest, log);

3
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/alerts/basic_license_essentials_tier/set_alert_tags.ts
View file

@ -40,8 +40,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const path = dataPathBuilder.getPath('auditbeat/hosts');
// Intentionally setting as @skipInQA, keeping tests running in MKI that should block release
describe('@ess @serverless @skipInQA set_alert_tags', () => {
describe('@ess @serverless set_alert_tags', () => {
describe('validation checks', () => {
it('should give errors when no alert ids are provided', async () => {
const { body } = await supertest

3
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/alerts/trial_license_complete_tier/assignments/assignments.ts
View file

@ -39,8 +39,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const path = dataPathBuilder.getPath('auditbeat/hosts');
// Intentionally setting as @skipInQA, keeping tests running in MKI that should block release
describe('@ess @serverless @skipInQA Alert User Assignment - ESS & Serverless', () => {
describe('@ess @serverless Alert User Assignment - ESS & Serverless', () => {
describe('validation checks', () => {
it('should give errors when no alert ids are provided', async () => {
const { body } = await supertest

3
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/alerts/trial_license_complete_tier/assignments/assignments_serverless.ts
View file

@ -33,8 +33,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const path = dataPathBuilder.getPath('auditbeat/hosts');
// Intentionally setting as @skipInQA, keeping tests running in MKI that should block release
describe('@serverless @skipInQA Alert User Assignment - Serverless', () => {
describe('@serverless Alert User Assignment - Serverless', () => {
before(async () => {
await esArchiver.load(path);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/alerts/trial_license_complete_tier/document_level_security.ts
View file

@ -74,7 +74,7 @@ export default ({ getService }: FtrProviderContext) => {
const esArchiver = getService('esArchiver');
const security = getService('security');
describe('@ess @serverless @brokenInServerless find alert with/without doc level security', () => {
describe('@ess @serverless @skipInServerless find alert with/without doc level security', () => {
before(async () => {
await security.role.create(
roleToAccessSecuritySolution.name,

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/date_numeric_types/basic_license_essentials_tier/date.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type date', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type date', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/date');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/date_numeric_types/basic_license_essentials_tier/double.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type double', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type double', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/double');
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/double_as_string');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/date_numeric_types/basic_license_essentials_tier/float.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type float', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type float', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/float');
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/float_as_string');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/date_numeric_types/basic_license_essentials_tier/integer.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type integer', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type integer', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/integer');
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/integer_as_string');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/ips/basic_license_essentials_tier/ip.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type ip', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type ip', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/ip');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/ips/basic_license_essentials_tier/ip_array.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type ip', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type ip', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/ip_as_array');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/keyword/basic_license_essentials_tier/keyword.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type keyword', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type keyword', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/keyword');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/keyword/basic_license_essentials_tier/keyword_array.ts
View file

@ -33,7 +33,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type keyword', () => {
describe('@serverles @serverlessQA @ess Rule exception operators for data type keyword', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/keyword_as_array');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/long/basic_license_essentials_tier/long.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type long', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type long', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/long');
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/long_as_string');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/text/basic_license_essentials_tier/text.ts
View file

@ -33,7 +33,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type text', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type text', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/text');
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/text_no_spaces');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/operators_data_types/text/basic_license_essentials_tier/text_array.ts
View file

@ -32,7 +32,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess Rule exception operators for data type text', () => {
describe('@serverless @serverlessQA @ess Rule exception operators for data type text', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_exceptions/text_as_array');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/workflows/basic_license_essentials_tier/create_endpoint_exceptions.ts
View file

@ -74,7 +74,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess create_endpoint_exceptions', () => {
describe('@serverless @serverlessQA @ess create_endpoint_exceptions', () => {
before(async () => {
await esArchiver.load(
'x-pack/test/functional/es_archives/rule_exceptions/endpoint_without_host_type'

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/workflows/basic_license_essentials_tier/create_rule_exceptions.ts
View file

@ -48,7 +48,7 @@ export default ({ getService }: FtrProviderContext) => {
const config = getService('config');
const ELASTICSEARCH_USERNAME = config.get('servers.kibana.username');
describe('@serverless @ess create "rule_default" exceptions', () => {
describe('@serverless @serverlessQA @ess create "rule_default" exceptions', () => {
before(async () => {
await createAlertsIndex(supertest, log);
});

3
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/workflows/basic_license_essentials_tier/exception_comments_serverless.ts
View file

@ -26,8 +26,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const supertestWithoutAuth = getService('supertestWithoutAuth');
// @skipInQA purposefully - only running tests in MKI whose failure should block release
describe('@serverless @skipInQA exception item comments - serverless specific behavior', () => {
describe('@serverless exception item comments - serverless specific behavior', () => {
describe('Rule Exceptions', () => {
afterEach(async () => {
await deleteAllExceptions(supertest, log);

3
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/workflows/basic_license_essentials_tier/exceptions_data_integrity.ts
View file

@ -37,8 +37,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
// @skipInQA purposefully - only running tests in MKI whose failure should block release
describe('@serverless @ess @skipInQA exceptions data integrity', () => {
describe('@serverless @ess exceptions data integrity', () => {
afterEach(async () => {
await deleteAllAlerts(supertest, log, es);
await deleteAllRules(supertest, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/workflows/basic_license_essentials_tier/find_rule_exception_references.ts
View file

@ -36,7 +36,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@serverless @ess find_rule_exception_references', () => {
describe('@serverless @serverlessQA @ess find_rule_exception_references', () => {
before(async () => {
await createAlertsIndex(supertest, log);
});

3
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/workflows/basic_license_essentials_tier/prebuilt_rules.ts
View file

@ -37,8 +37,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
// @skipInQA purposefully - only running tests in MKI whose failure should block release
describe('@serverless @ess @skipInQA exceptions workflows for prebuilt rules', () => {
describe('@serverless @ess exceptions workflows for prebuilt rules', () => {
describe('creating rules with exceptions', () => {
beforeEach(async () => {
await createAlertsIndex(supertest, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/exceptions/workflows/basic_license_essentials_tier/rule_exceptions_execution.ts
View file

@ -58,7 +58,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const path = dataPathBuilder.getPath('auditbeat/hosts');
describe('@serverless @ess rule exceptions execution', () => {
describe('@serverless @serverlessQA @ess rule exceptions execution', () => {
before(async () => {
await esArchiver.load(path);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/eql.ts
View file

@ -77,7 +77,7 @@ export default ({ getService }: FtrProviderContext) => {
const auditPath = dataPathBuilder.getPath('auditbeat/hosts');
// FLAKY: https://github.com/elastic/kibana/issues/180641
describe.skip('@ess @serverless EQL type rules', () => {
describe.skip('@ess @serverless @serverlessQA EQL type rules', () => {
const { indexListOfDocuments } = dataGeneratorFactory({
es,
index: 'ecs_compliant',

8
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/machine_learning.ts
View file

@ -87,7 +87,7 @@ export default ({ getService }: FtrProviderContext) => {
};
// FLAKY: https://github.com/elastic/kibana/issues/171426
describe.skip('@ess @serverless Machine learning type rules', () => {
describe.skip('@ess @serverless @serverlessQA Machine learning type rules', () => {
before(async () => {
// Order is critical here: auditbeat data must be loaded before attempting to start the ML job,
// as the job looks for certain indices on start
@ -214,7 +214,7 @@ export default ({ getService }: FtrProviderContext) => {
expect(metricsResponse.metrics?.task_run?.value.by_type['alerting:siem__mlRule']).toEqual(1);
});
it('@skipInQA generates max alerts warning when circuit breaker is exceeded', async () => {
it('@skipInServerlessMKI generates max alerts warning when circuit breaker is exceeded', async () => {
const { logs } = await previewRule({
supertest,
rule: { ...rule, anomaly_threshold: 1, max_signals: 5 }, // This threshold generates 10 alerts with the current esArchive
@ -230,7 +230,7 @@ export default ({ getService }: FtrProviderContext) => {
expect(logs[0].warnings).not.toContain(getMaxAlertsWarning());
});
it('@skipInQA should create 7 alerts from ML rule when records meet anomaly_threshold', async () => {
it('@skipInServerlessMKI should create 7 alerts from ML rule when records meet anomaly_threshold', async () => {
const { previewId } = await previewRule({
supertest,
rule: { ...rule, anomaly_threshold: 20 },
@ -309,7 +309,7 @@ export default ({ getService }: FtrProviderContext) => {
await esArchiver.unload('x-pack/test/functional/es_archives/entity/risks');
});
it('@skipInQA should be enriched with host risk score', async () => {
it('@skipInServerlessMKI should be enriched with host risk score', async () => {
const { previewId } = await previewRule({ supertest, rule });
const previewAlerts = await getPreviewAlerts({ es, previewId });
expect(previewAlerts.length).toBe(1);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/new_terms.ts
View file

@ -81,7 +81,7 @@ export default ({ getService }: FtrProviderContext) => {
};
// Failing: See https://github.com/elastic/kibana/issues/180236
describe.skip('@ess @serverless New terms type rules', () => {
describe.skip('@ess @serverless @serverlessQA New terms type rules', () => {
before(async () => {
await esArchiver.load(path);
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/new_terms');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/new_terms_alert_suppression.ts
View file

@ -55,7 +55,7 @@ export default ({ getService }: FtrProviderContext) => {
const historicalWindowStart = '2019-10-13T05:00:04.000Z';
describe('@ess @serverless New terms type rules, alert suppression', () => {
describe('@ess @serverless @serverlessQA New terms type rules, alert suppression', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/ecs_compliant');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/non_ecs_fields.ts
View file

@ -58,7 +58,7 @@ export default ({ getService }: FtrProviderContext) => {
};
};
describe('@ess @serverless Non ECS fields in alert document source', () => {
describe('@ess @serverless @serverlessQA Non ECS fields in alert document source', () => {
before(async () => {
await esArchiver.load(
'x-pack/test/functional/es_archives/security_solution/ecs_non_compliant'

4
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/query.ts
View file

@ -98,7 +98,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const auditbeatPath = dataPathBuilder.getPath('auditbeat/hosts');
describe('@ess @serverless Query type rules', () => {
describe('@ess @serverless @serverlessQA Query type rules', () => {
before(async () => {
await esArchiver.load(auditbeatPath);
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/alerts/8.8.0', {
@ -2373,7 +2373,7 @@ export default ({ getService }: FtrProviderContext) => {
});
// TODO: Ask YARA
describe('@brokenInServerless legacy investigation_fields', () => {
describe('@skipInServerless legacy investigation_fields', () => {
let ruleWithLegacyInvestigationField: Rule<BaseRuleParams>;
beforeEach(async () => {

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/saved_query.ts
View file

@ -43,7 +43,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const path = dataPathBuilder.getPath('auditbeat/hosts');
describe('@ess @serverless Saved query type rules', () => {
describe('@ess @serverless @serverlessQA Saved query type rules', () => {
before(async () => {
await esArchiver.load(path);
});

3
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/threat_match.ts
View file

@ -171,7 +171,8 @@ export default ({ getService }: FtrProviderContext) => {
/**
* Specific api integration tests for threat matching rule type
*/
describe('@ess @serverless Threat match type rules', () => {
// FLAKY: https://github.com/elastic/kibana/issues/155304
describe('@ess @serverless @serverlessQA Threat match type rules', () => {
before(async () => {
await esArchiver.load(audibeatHostsPath);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/threat_match_alert_suppression.ts
View file

@ -157,7 +157,7 @@ export default ({ getService }: FtrProviderContext) => {
},
];
describe('@ess @serverless Indicator match type rules, alert suppression', () => {
describe('@ess @serverless @serverlessQA Indicator match type rules, alert suppression', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/ecs_compliant');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/threshold.ts
View file

@ -47,7 +47,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const path = dataPathBuilder.getPath('auditbeat/hosts');
describe('@ess @serverless Threshold type rules', () => {
describe('@ess @serverless @serverlessQA Threshold type rules', () => {
before(async () => {
await esArchiver.load(path);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/execution_logic/threshold_alert_suppression.ts
View file

@ -49,7 +49,7 @@ export default ({ getService }: FtrProviderContext) => {
const dataPathBuilder = new EsArchivePathBuilder(isServerless);
const path = dataPathBuilder.getPath('auditbeat/hosts');
describe('@ess @serverless Threshold type rules, alert suppression', () => {
describe('@ess @serverless @serverlessQA Threshold type rules, alert suppression', () => {
const { indexListOfDocuments, indexGeneratedDocuments } = dataGeneratorFactory({
es,
index: 'ecs_compliant',

6
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/ignore_fields.ts
View file

@ -46,7 +46,7 @@ export default ({ getService }: FtrProviderContext): void => {
* server/lib/detection_engine/signals/source_fields_merging/utils/is_ignored.ts
* server/lib/detection_engine/signals/source_fields_merging/utils/is_eql_bug_77152.ts
*/
describe('@ess @serverless ignore_fields', () => {
describe('@ess @serverless @serverlessQA ignore_fields', () => {
const supertest = getService('supertest');
const esArchiver = getService('esArchiver');
const log = getService('log');
@ -69,7 +69,7 @@ export default ({ getService }: FtrProviderContext): void => {
await deleteAllRules(supertest, log);
});
it('@skipInQA should ignore the field of "testing_ignored"', async () => {
it('@skipInServerlessMKI should ignore the field of "testing_ignored"', async () => {
const rule = getEqlRuleForAlertTesting(['ignore_fields']);
const { id } = await createRule(supertest, log, rule);
@ -84,7 +84,7 @@ export default ({ getService }: FtrProviderContext): void => {
expect(hits).to.eql([undefined, undefined, undefined, undefined]);
});
it('@skipInQA should ignore the field of "testing_regex"', async () => {
it('@skipInServerlessMKI should ignore the field of "testing_regex"', async () => {
const rule = getEqlRuleForAlertTesting(['ignore_fields']);
const { id } = await createRule(supertest, log, rule);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/keyword_family/const_keyword.ts
View file

@ -31,7 +31,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@ess @serverless Rule detects against a keyword of event.dataset', () => {
describe('@ess @serverless @serverlessQA Rule detects against a keyword of event.dataset', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_keyword_family/const_keyword');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/keyword_family/keyword.ts
View file

@ -50,7 +50,7 @@ export default ({ getService }: FtrProviderContext) => {
await deleteAllRules(supertest, log);
});
describe('@ess @serverless "kql" rule type', () => {
describe('@ess @serverless @serverlessQA "kql" rule type', () => {
it('should detect the "dataset_name_1" from "event.dataset"', async () => {
const rule: QueryRuleCreateProps = {
...getRuleForAlertTesting(['keyword']),

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/keyword_family/keyword_mixed_with_const.ts
View file

@ -31,7 +31,7 @@ export default ({ getService }: FtrProviderContext) => {
const log = getService('log');
const es = getService('es');
describe('@ess @serverless Rule detects against a keyword and constant_keyword of event.dataset', () => {
describe('@ess @serverless @serverlessQA Rule detects against a keyword and constant_keyword of event.dataset', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/rule_keyword_family/const_keyword');
await esArchiver.load('x-pack/test/functional/es_archives/rule_keyword_family/keyword');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/runtime.ts
View file

@ -31,7 +31,7 @@ export default ({ getService }: FtrProviderContext) => {
hostname: string;
}
describe('@ess @serverless Tests involving runtime fields of source indexes and the alerts index', () => {
describe('@ess @serverless @serverlessQA Tests involving runtime fields of source indexes and the alerts index', () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/runtime');
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/detection_engine/rule_execution_logic/trial_license_complete_tier/timestamps.ts
View file

@ -44,7 +44,7 @@ export default ({ getService }: FtrProviderContext) => {
* the "signal.original_time" field, ensuring that timestamp overrides operate, and ensuring that
* partial errors happen correctly
*/
describe('@ess @serverless timestamp tests', () => {
describe('@ess @serverless @serverlessQA timestamp tests', () => {
describe('alerts generated from events with a timestamp in seconds is converted correctly into the forced ISO8601 format when copying', () => {
beforeEach(async () => {
await createAlertsIndex(supertest, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/bundled_prebuilt_rules_package/trial_license_complete_tier/install_latest_bundled_prebuilt_rules.ts
View file

@ -31,7 +31,7 @@ export default ({ getService }: FtrProviderContext): void => {
/* from a package that was bundled with Kibana */
//
// FLAKY: https://github.com/elastic/kibana/issues/180087
describe.skip('@ess @serverless @skipInQA install_bundled_prebuilt_rules', () => {
describe.skip('@ess @serverless @skipInServerlessMKI install_bundled_prebuilt_rules', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
await deleteAllPrebuiltRuleAssets(es, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/bundled_prebuilt_rules_package/trial_license_complete_tier/prerelease_packages.ts
View file

@ -31,7 +31,7 @@ export default ({ getService }: FtrProviderContext): void => {
/* (We use high mock version numbers to prevent clashes with real packages downloaded in other tests.)
/* To do assertions on which packages have been installed, 99.0.0 has a single rule to install,
/* while 99.0.1-beta.1 has 2 rules to install. Also, both packages have the version as part of the rule names. */
describe('@ess @serverless @skipInQA prerelease_packages', () => {
describe('@ess @serverless @skipInServerlessMKI prerelease_packages', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
await deleteAllPrebuiltRuleAssets(es, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/large_prebuilt_rules_package/trial_license_complete_tier/install_large_prebuilt_rules_package.ts
View file

@ -18,7 +18,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @serverless @skipInQA install_large_prebuilt_rules_package', () => {
describe('@ess @serverless @skipInServerlessMKI install_large_prebuilt_rules_package', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
await deleteAllPrebuiltRuleAssets(es, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/management/trial_license_complete_tier/fleet_integration.ts
View file

@ -22,7 +22,7 @@ export default ({ getService }: FtrProviderContext): void => {
const log = getService('log');
const retry = getService('retry');
describe('@ess @serverless @skipInQA install_prebuilt_rules_from_real_package', () => {
describe('@ess @serverless @skipInServerlessMKI install_prebuilt_rules_from_real_package', () => {
beforeEach(async () => {
await deletePrebuiltRulesFleetPackage(supertest);
await deleteAllRules(supertest, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/management/trial_license_complete_tier/get_prebuilt_rules_status.ts
View file

@ -30,7 +30,7 @@ export default ({ getService }: FtrProviderContext): void => {
const es = getService('es');
const log = getService('log');
describe('@ess @serverless @skipInQA Prebuilt Rules status', () => {
describe('@ess @serverless @skipInServerlessMKI Prebuilt Rules status', () => {
describe('get_prebuilt_rules_status', () => {
beforeEach(async () => {
await deleteAllPrebuiltRuleAssets(es, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/management/trial_license_complete_tier/get_prebuilt_timelines_status.ts
View file

@ -18,7 +18,7 @@ export default ({ getService }: FtrProviderContext): void => {
const es = getService('es');
const log = getService('log');
describe('@ess @serverless @skipInQA get_prebuilt_timelines_status', () => {
describe('@ess @serverless @skipInServerlessMKI get_prebuilt_timelines_status', () => {
beforeEach(async () => {
await deleteAllTimelines(es, log);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/management/trial_license_complete_tier/install_prebuilt_rules.ts
View file

@ -24,7 +24,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @serverless @skipInQA install prebuilt rules from package without historical versions with mock rule assets', () => {
describe('@ess @serverless @skipInServerlessMKI install prebuilt rules from package without historical versions with mock rule assets', () => {
const getRuleAssetSavedObjects = () => [
createRuleAssetSavedObject({ rule_id: 'rule-1', version: 1 }),
createRuleAssetSavedObject({ rule_id: 'rule-2', version: 2 }),

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/management/trial_license_complete_tier/install_prebuilt_rules_with_historical_versions.ts
View file

@ -24,7 +24,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @serverless @skipInQA install prebuilt rules from package with historical versions with mock rule assets', () => {
describe('@ess @serverless @skipInServerlessMKI install prebuilt rules from package with historical versions with mock rule assets', () => {
const getRuleAssetSavedObjects = () => [
createRuleAssetSavedObject({ rule_id: 'rule-1', version: 1 }),
createRuleAssetSavedObject({ rule_id: 'rule-1', version: 2 }),

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/management/trial_license_complete_tier/upgrade_prebuilt_rules.ts
View file

@ -27,7 +27,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @serverless @skipInQA upgrade prebuilt rules from package without historical versions with mock rule assets', () => {
describe('@ess @serverless @skipInServerlessMKI upgrade prebuilt rules from package without historical versions with mock rule assets', () => {
const getRuleAssetSavedObjects = () => [
createRuleAssetSavedObject({ rule_id: 'rule-1', version: 1 }),
createRuleAssetSavedObject({ rule_id: 'rule-2', version: 2 }),

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/management/trial_license_complete_tier/upgrade_prebuilt_rules_with_historical_versions.ts
View file

@ -24,7 +24,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @serverless @skipInQA upgrade prebuilt rules from package with historical versions with mock rule assets', () => {
describe('@ess @serverless @skipInServerlessMKI upgrade prebuilt rules from package with historical versions with mock rule assets', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
await deleteAllTimelines(es, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/prebuilt_rules/update_prebuilt_rules_package/trial_license_complete_tier/update_prebuilt_rules_package.ts
View file

@ -62,7 +62,7 @@ export default ({ getService }: FtrProviderContext): void => {
return getPackageResponse.body.item.version ?? '';
};
describe('@ess @serverless @skipInQA update_prebuilt_rules_package', () => {
describe('@ess @serverless @skipInServerlessMKI update_prebuilt_rules_package', () => {
before(async () => {
const configFilePath = path.resolve(REPO_ROOT, 'fleet_packages.json');
const fleetPackages = await fs.readFile(configFilePath, 'utf8');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_bulk_actions/trial_license_complete_tier/perform_bulk_action.ts
View file

@ -85,7 +85,7 @@ export default ({ getService }: FtrProviderContext): void => {
const createWebHookConnector = () => createConnector(getWebHookAction());
const createSlackConnector = () => createConnector(getSlackAction());
describe('@ess @serverless @brokenInServerless @skipInQA perform_bulk_action', () => {
describe('@ess @serverless @skipInServerless perform_bulk_action', () => {
beforeEach(async () => {
await createAlertsIndex(supertest, log);
await esArchiver.load('x-pack/test/functional/es_archives/auditbeat/hosts');

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_bulk_actions/trial_license_complete_tier/perform_bulk_action_dry_run.ts
View file

@ -24,7 +24,7 @@ export default ({ getService }: FtrProviderContext): void => {
const log = getService('log');
const es = getService('es');
describe('@ess @serverless @skipInQA perform_bulk_action dry_run', () => {
describe('@ess @serverless @skipInServerlessMKI perform_bulk_action dry_run', () => {
beforeEach(async () => {
await createAlertsIndex(supertest, log);
});

6
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_creation/trial_license_complete_tier/create_rules.ts
View file

@ -346,7 +346,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless t1_analyst', () => {
describe('@skipInServerless t1_analyst', () => {
const role = ROLES.t1_analyst;
beforeEach(async () => {
@ -482,7 +482,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless missing timestamps', () => {
describe('@skipInServerless missing timestamps', () => {
beforeEach(async () => {
await es.indices.delete({ index: 'myfakeindex-1', ignore_unavailable: true });
await es.indices.create({
@ -561,7 +561,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless per-action frequencies', () => {
describe('@skipInServerless per-action frequencies', () => {
beforeEach(async () => {
await deleteAllAlerts(supertest, log, es);
await deleteAllRules(supertest, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_creation/trial_license_complete_tier/create_rules_bulk.ts
View file

@ -45,7 +45,7 @@ export default ({ getService }: FtrProviderContext): void => {
const es = getService('es');
// See https://github.com/elastic/kibana/issues/130963 for discussion on deprecation
describe('@ess @brokenInServerless @skipInQA create_rules_bulk', () => {
describe('@ess @skipInServerless create_rules_bulk', () => {
describe('deprecations', () => {
afterEach(async () => {
await deleteAllRules(supertest, log);

4
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_creation/trial_license_complete_tier/preview_rules.ts
View file

@ -95,7 +95,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless t1_analyst', () => {
describe('@skipInServerless t1_analyst', () => {
const role = ROLES.t1_analyst;
beforeEach(async () => {
@ -116,7 +116,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless hunter', () => {
describe('@skipInServerless hunter', () => {
const role = ROLES.hunter;
beforeEach(async () => {

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_delete/trial_license_complete_tier/delete_rules_bulk.ts
View file

@ -40,7 +40,7 @@ export default ({ getService }: FtrProviderContext): void => {
const ELASTICSEARCH_USERNAME = config.get('servers.kibana.username');
// See https://github.com/elastic/kibana/issues/130963 for discussion on deprecation
describe('@ess @brokenInServerless @skipInQA delete_rules_bulk', () => {
describe('@ess @skipInServerlesMKI delete_rules_bulk', () => {
describe('deprecations', () => {
it('should return a warning header', async () => {
await createRule(supertest, log, getSimpleRule());

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_import_export/basic_license_essentials_tier/import_rules_with_overwrite.ts
View file

@ -16,7 +16,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @serverless @skipInQA import_rules with rule overwrite set to "true"', () => {
describe('@ess @serverless @skipInServerlessMKI import_rules with rule overwrite set to "true"', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_import_export/trial_license_complete_tier/export_rules.ts
View file

@ -27,7 +27,7 @@ export default ({ getService }: FtrProviderContext): void => {
const log = getService('log');
const es = getService('es');
describe('@ess @brokenInServerless @skipInQA export_rules', () => {
describe('@ess @skipInServerlessMKI export_rules', () => {
describe('exporting rules', () => {
beforeEach(async () => {
await createAlertsIndex(supertest, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_import_export/trial_license_complete_tier/import_connectors.ts
View file

@ -16,7 +16,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @brokenInServerless @skipInQA import action connectors', () => {
describe('@ess @skipInServerlessMKI import action connectors', () => {
const CONNECTOR_ID = '1be16246-642a-4ed8-bfd3-b47f8c7d7055';
const ANOTHER_CONNECTOR_ID = 'abc16246-642a-4ed8-bfd3-b47f8c7d7055';
const CUSTOM_ACTION_CONNECTOR = {

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_import_export/trial_license_complete_tier/import_rules.ts
View file

@ -171,7 +171,7 @@ export default ({ getService }: FtrProviderContext): void => {
const log = getService('log');
const esArchiver = getService('esArchiver');
describe('@ess @brokenInServerless @skipInQA import_rules', () => {
describe('@ess @serverless @skipInServerlessMKI import_rules', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_import_export/trial_license_complete_tier/import_rules_with_overwrite.ts
View file

@ -16,7 +16,7 @@ export default ({ getService }: FtrProviderContext): void => {
const supertest = getService('supertest');
const log = getService('log');
describe('@ess @serverless @skipInQA import_rules with rule overwrite set to "true"', () => {
describe('@ess @serverless @skipInServerlessMKI import_rules with rule overwrite set to "true"', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
});

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_patch/basic_license_essentials_tier/patch_rules.ts
View file

@ -59,7 +59,7 @@ export default ({ getService }: FtrProviderContext) => {
expect(bodyToCompare).to.eql(expectedRule);
});
it('@brokenInServerless should return a "403 forbidden" using a rule_id of type "machine learning"', async () => {
it('@skipInServerless should return a "403 forbidden" using a rule_id of type "machine learning"', async () => {
await createRule(supertest, log, getSimpleRule('rule-1'));
// patch a simple rule's type to machine learning

10
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_patch/trial_license_complete_tier/patch_rules.ts
View file

@ -47,7 +47,7 @@ export default ({ getService }: FtrProviderContext) => {
const config = getService('config');
const ELASTICSEARCH_USERNAME = config.get('servers.kibana.username');
describe('@ess @serverless @skipInQA patch_rules', () => {
describe('@ess @serverless @skipInServerlessMKI patch_rules', () => {
describe('patch rules', () => {
beforeEach(async () => {
await createAlertsIndex(supertest, log);
@ -422,7 +422,7 @@ export default ({ getService }: FtrProviderContext) => {
describe('actions without frequencies', () => {
[undefined, NOTIFICATION_THROTTLE_NO_ACTIONS, NOTIFICATION_THROTTLE_RULE].forEach(
(throttle) => {
it(`@brokenInServerless it sets each action's frequency attribute to default value when 'throttle' is ${throttle}`, async () => {
it(`@skipInServerless it sets each action's frequency attribute to default value when 'throttle' is ${throttle}`, async () => {
const actionsWithoutFrequencies = await getActionsWithoutFrequencies(supertest);
// create simple rule
@ -452,7 +452,7 @@ export default ({ getService }: FtrProviderContext) => {
// Action throttle cannot be shorter than the schedule interval which is by default is 5m
['300s', '5m', '3h', '4d'].forEach((throttle) => {
it(`@brokenInServerless it correctly transforms 'throttle = ${throttle}' and sets it as a frequency of each action`, async () => {
it(`@skipInServerless it correctly transforms 'throttle = ${throttle}' and sets it as a frequency of each action`, async () => {
const actionsWithoutFrequencies = await getActionsWithoutFrequencies(supertest);
// create simple rule
@ -490,7 +490,7 @@ export default ({ getService }: FtrProviderContext) => {
'10h',
'2d',
].forEach((throttle) => {
it(`@brokenInServerless it does not change actions frequency attributes when 'throttle' is '${throttle}'`, async () => {
it(`@skipInServerless it does not change actions frequency attributes when 'throttle' is '${throttle}'`, async () => {
const actionsWithFrequencies = await getActionsWithFrequencies(supertest);
// create simple rule
@ -516,7 +516,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless some actions with frequencies', () => {
describe('@skipInServerless some actions with frequencies', () => {
[undefined, NOTIFICATION_THROTTLE_NO_ACTIONS, NOTIFICATION_THROTTLE_RULE].forEach(
(throttle) => {
it(`it overrides each action's frequency attribute to default value when 'throttle' is ${throttle}`, async () => {

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_patch/trial_license_complete_tier/patch_rules_bulk.ts
View file

@ -44,7 +44,7 @@ export default ({ getService }: FtrProviderContext) => {
const ELASTICSEARCH_USERNAME = config.get('servers.kibana.username');
// See https://github.com/elastic/kibana/issues/130963 for discussion on deprecation
describe('@ess @brokenInServerless @skipInQA patch_rules_bulk', () => {
describe('@ess @skipInServerless patch_rules_bulk', () => {
describe('deprecations', () => {
afterEach(async () => {
await deleteAllRules(supertest, log);

4
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_read/trial_license_complete_tier/read_rules.ts
View file

@ -108,7 +108,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless @skipInQA should be able to a read a execute immediately action correctly', async () => {
it('@skipInServerless should be able to a read a execute immediately action correctly', async () => {
// create connector/action
const { body: hookAction } = await supertest
.post('/api/actions/action')
@ -150,7 +150,7 @@ export default ({ getService }: FtrProviderContext) => {
expect(bodyToCompare).to.eql(ruleWithActions);
});
it('@brokenInServerless should be able to a read a scheduled action correctly', async () => {
it('@skipInServerless should be able to a read a scheduled action correctly', async () => {
// create connector/action
const { body: hookAction } = await supertest
.post('/api/actions/action')

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_update/basic_license_essentials_tier/update_rules.ts
View file

@ -64,7 +64,7 @@ export default ({ getService }: FtrProviderContext) => {
expect(bodyToCompare).to.eql(expectedRule);
});
it('@brokenInServerless should return a 403 forbidden if it is a machine learning job', async () => {
it('@skipInServerless should return a 403 forbidden if it is a machine learning job', async () => {
await createRule(supertest, log, getSimpleRule('rule-1'));
// update a simple rule's type to try to be a machine learning job type

10
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_update/trial_license_complete_tier/update_rules.ts
View file

@ -50,7 +50,7 @@ export default ({ getService }: FtrProviderContext) => {
const config = getService('config');
const ELASTICSEARCH_USERNAME = config.get('servers.kibana.username');
describe('@ess @serverless @skipInQA update_rules', () => {
describe('@ess @serverless @skipInServerlessMKI update_rules', () => {
describe('update rules', () => {
beforeEach(async () => {
await createAlertsIndex(supertest, log);
@ -142,7 +142,7 @@ export default ({ getService }: FtrProviderContext) => {
expect(bodyToCompare).to.eql(outputRule);
});
it('@brokenInServerless should update a single rule property and remove the action', async () => {
it('@skipInServerless should update a single rule property and remove the action', async () => {
const [connector1] = await Promise.all([
supertest
.post(`/api/actions/connector`)
@ -562,7 +562,7 @@ export default ({ getService }: FtrProviderContext) => {
return removeServerGeneratedPropertiesIncludingRuleId(updatedRule);
};
describe('@brokenInServerless actions without frequencies', () => {
describe('@skipInServerless actions without frequencies', () => {
[undefined, NOTIFICATION_THROTTLE_NO_ACTIONS, NOTIFICATION_THROTTLE_RULE].forEach(
(throttle) => {
it(`it sets each action's frequency attribute to default value when 'throttle' is ${throttle}`, async () => {
@ -623,7 +623,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless actions with frequencies', () => {
describe('@skipInServerless actions with frequencies', () => {
[
undefined,
NOTIFICATION_THROTTLE_NO_ACTIONS,
@ -658,7 +658,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless some actions with frequencies', () => {
describe('@skipInServerless some actions with frequencies', () => {
[undefined, NOTIFICATION_THROTTLE_NO_ACTIONS, NOTIFICATION_THROTTLE_RULE].forEach(
(throttle) => {
it(`it overrides each action's frequency attribute to default value when 'throttle' is ${throttle}`, async () => {

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/rules_management/rule_update/trial_license_complete_tier/update_rules_bulk.ts
View file

@ -54,7 +54,7 @@ export default ({ getService }: FtrProviderContext) => {
const ELASTICSEARCH_USERNAME = config.get('servers.kibana.username');
// See https://github.com/elastic/kibana/issues/130963 for discussion on deprecation
describe('@ess @brokenInServerless @skipInQA update_rules_bulk', () => {
describe('@ess update_rules_bulk', () => {
describe('deprecations', () => {
afterEach(async () => {
await deleteAllRules(supertest, log);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/telemetry/trial_license_complete_tier/task_based/all_types.ts
View file

@ -43,7 +43,7 @@ export default ({ getService }: FtrProviderContext) => {
await deleteAllExceptions(supertest, log);
});
it('@skipInQA should only have task metric values when no rules are running', async () => {
it('@skipInServerlessMKI should only have task metric values when no rules are running', async () => {
await retry.try(async () => {
const stats = await getSecurityTelemetryStats(supertest, log);
removeExtraFieldsFromTelemetryStats(stats);

14
x-pack/test/security_solution_api_integration/test_suites/detections_response/telemetry/trial_license_complete_tier/task_based/detection_rules.ts
View file

@ -55,7 +55,7 @@ export default ({ getService }: FtrProviderContext) => {
});
describe('custom rules should never show any detection_rules telemetry data for each list type', () => {
it('@skipInQA should NOT give telemetry/stats for an exception list of type "detection"', async () => {
it('@skipInServerlessMKI should NOT give telemetry/stats for an exception list of type "detection"', async () => {
const rule = getRuleForAlertTesting(['telemetry'], 'rule-1', false);
// create an exception list container of type "detection"
@ -111,7 +111,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@skipInQA should NOT give telemetry/stats for an exception list of type "endpoint"', async () => {
it('@skipInServerlessMKI should NOT give telemetry/stats for an exception list of type "endpoint"', async () => {
const rule = getRuleForAlertTesting(['telemetry'], 'rule-1', false);
// create an exception list container of type "detection"
@ -167,7 +167,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@skipInQA should NOT give telemetry/stats for an exception list of type "endpoint_trusted_apps"', async () => {
it('@skipInServerlessMKI should NOT give telemetry/stats for an exception list of type "endpoint_trusted_apps"', async () => {
const rule = getRuleForAlertTesting(['telemetry'], 'rule-1', false);
// create an exception list container of type "detection"
@ -223,7 +223,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@skipInQA should NOT give telemetry/stats for an exception list of type "endpoint_events"', async () => {
it('@skipInServerlessMKI should NOT give telemetry/stats for an exception list of type "endpoint_events"', async () => {
const rule = getRuleForAlertTesting(['telemetry'], 'rule-1', false);
// create an exception list container of type "detection"
@ -279,7 +279,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@skipInQA should NOT give telemetry/stats for an exception list of type "endpoint_host_isolation_exceptions"', async () => {
it('@skipInServerlessMKI should NOT give telemetry/stats for an exception list of type "endpoint_host_isolation_exceptions"', async () => {
const rule = getRuleForAlertTesting(['telemetry'], 'rule-1', false);
// create an exception list container of type "detection"
@ -336,7 +336,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@skipInQA pre-built/immutable/elastic rules should show detection_rules telemetry data for each list type', () => {
describe('@skipInServerlessMKI pre-built/immutable/elastic rules should show detection_rules telemetry data for each list type', () => {
beforeEach(async () => {
// install prepackaged rules to get immutable rules for testing
await installMockPrebuiltRules(supertest, es);
@ -789,7 +789,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@skipInQA pre-built/immutable/elastic rules should show detection_rules telemetry data for multiple list items and types', () => {
describe('@skipInServerlessMKI pre-built/immutable/elastic rules should show detection_rules telemetry data for multiple list items and types', () => {
beforeEach(async () => {
// install prepackaged rules to get immutable rules for testing
await installMockPrebuiltRules(supertest, es);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/telemetry/trial_license_complete_tier/usage_collector/all_types.ts
View file

@ -24,7 +24,7 @@ export default ({ getService }: FtrProviderContext) => {
const retry = getService('retry');
const es = getService('es');
describe('@ess @serverless @skipInQA Detection rule telemetry', async () => {
describe('@ess @serverless @skipInServerlessMKI Detection rule telemetry', async () => {
before(async () => {
await esArchiver.load('x-pack/test/functional/es_archives/security_solution/telemetry');
});

8
x-pack/test/security_solution_api_integration/test_suites/detections_response/telemetry/trial_license_complete_tier/usage_collector/detection_rule_status.ts
View file

@ -123,7 +123,7 @@ export default ({ getService }: FtrProviderContext) => {
expect(stats?.detection_rules.detection_rule_usage).to.eql(expectedRuleUsage);
});
it('@skipInQA should have zero values for "detection_rule_status.all_rules" rules that are not query based', () => {
it('@skipInServerlessMKI should have zero values for "detection_rule_status.all_rules" rules that are not query based', () => {
expect(stats?.detection_rules.detection_rule_status.all_rules.eql).to.eql(
getInitialSingleEventMetric()
);
@ -175,7 +175,7 @@ export default ({ getService }: FtrProviderContext) => {
);
});
it('@skipInQA should have non zero values for "index_duration"', () => {
it('@skipInServerlessMKI should have non zero values for "index_duration"', () => {
expect(
stats?.detection_rules.detection_rule_status.custom_rules.query.index_duration.max
).to.be.above(1);
@ -208,11 +208,11 @@ export default ({ getService }: FtrProviderContext) => {
).to.be.above(1);
});
it('@skipInQA should have non zero values for "succeeded"', () => {
it('@skipInServerlessMKI should have non zero values for "succeeded"', () => {
expect(stats?.detection_rules.detection_rule_status.custom_rules.query.succeeded).to.eql(1);
});
it('@skipInQA should have non zero values for "succeeded", "index_duration", "search_duration" and "enrichment_duration"', () => {
it('@skipInServerlessMKI should have non zero values for "succeeded", "index_duration", "search_duration" and "enrichment_duration"', () => {
expect(
stats?.detection_rules.detection_rule_status.custom_rules.query.index_duration.max
).to.be.above(1);

36
x-pack/test/security_solution_api_integration/test_suites/detections_response/telemetry/trial_license_complete_tier/usage_collector/detection_rules.ts
View file

@ -162,7 +162,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "notifications_enabled" to be "1" for rule that has at least "1" action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerless should show "notifications_enabled" to be "1" for rule that has at least "1" action(s) and the alert is "enabled"/"active"', async () => {
const rule = getRuleForAlertTesting(['telemetry']);
const hookAction = await createWebHookRuleAction(supertest);
const ruleToCreate = getRuleWithWebHookAction(hookAction.id, true, rule);
@ -191,7 +191,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
it('@skipInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
const rule = getRuleForAlertTesting(['telemetry'], 'rule-1', false);
const { id } = await createRule(supertest, log, rule);
const hookAction = await createWebHookRuleAction(supertest);
@ -217,7 +217,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
const rule = getRuleForAlertTesting(['telemetry']);
const { id } = await createRule(supertest, log, rule);
const hookAction = await createWebHookRuleAction(supertest);
@ -246,7 +246,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
describe('@brokenInServerless legacy investigation fields', () => {
describe('@skipInServerless legacy investigation fields', () => {
beforeEach(async () => {
await deleteAllRules(supertest, log);
await createRuleThroughAlertingEndpoint(
@ -411,7 +411,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
it('@skipInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
const rule = getEqlRuleForAlertTesting(['telemetry'], 'rule-1', false);
const { id } = await createRule(supertest, log, rule);
const hookAction = await createWebHookRuleAction(supertest);
@ -436,7 +436,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
const rule = getEqlRuleForAlertTesting(['telemetry']);
const { id } = await createRule(supertest, log, rule);
const hookAction = await createWebHookRuleAction(supertest);
@ -609,7 +609,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
it('@skipInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
const rule: ThresholdRuleCreateProps = {
...getThresholdRuleForAlertTesting(['telemetry'], 'rule-1', false),
threshold: {
@ -640,7 +640,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
const rule: ThresholdRuleCreateProps = {
...getThresholdRuleForAlertTesting(['telemetry']),
threshold: {
@ -788,7 +788,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
it('@skipInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
const rule = getSimpleMlRule();
const { id } = await createRule(supertest, log, rule);
const hookAction = await createWebHookRuleAction(supertest);
@ -813,7 +813,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
const rule = getSimpleMlRule('rule-1', true);
const { id } = await createRule(supertest, log, rule);
const hookAction = await createWebHookRuleAction(supertest);
@ -988,7 +988,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
it('@skipInServerless should show "legacy_notifications_disabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "disabled"/"in-active"', async () => {
const rule = getSimpleThreatMatch();
const { id } = await createRule(supertest, log, rule);
const hookAction = await createWebHookRuleAction(supertest);
@ -1013,7 +1013,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerless should show "legacy_notifications_enabled" to be "1" for rule that has at least "1" legacy action(s) and the alert is "enabled"/"active"', async () => {
const rule: ThreatMatchRuleCreateProps = {
...getSimpleThreatMatch('rule-1', true),
index: ['telemetry'],
@ -1059,7 +1059,7 @@ export default ({ getService }: FtrProviderContext) => {
});
describe('"pre-packaged"/"immutable" rules', async () => {
it('@skipInQA should show stats for totals for in-active pre-packaged rules', async () => {
it('@skipInServerless should show stats for totals for in-active pre-packaged rules', async () => {
await installMockPrebuiltRules(supertest, es);
await retry.try(async () => {
const stats = await getStats(supertest, log);
@ -1092,7 +1092,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@skipInQA should show stats for the detection_rule_details for a specific pre-packaged rule', async () => {
it('@skipInServerlessMKI should show stats for the detection_rule_details for a specific pre-packaged rule', async () => {
await installMockPrebuiltRules(supertest, es);
await retry.try(async () => {
const stats = await getStats(supertest, log);
@ -1123,7 +1123,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@skipInQA should show "notifications_disabled" to be "1", "has_notification" to be "true, "has_legacy_notification" to be "false" for rule that has at least "1" action(s) and the alert is "disabled"/"in-active"', async () => {
it('@skipInServerlessMKI should show "notifications_disabled" to be "1", "has_notification" to be "true, "has_legacy_notification" to be "false" for rule that has at least "1" action(s) and the alert is "disabled"/"in-active"', async () => {
await installMockPrebuiltRules(supertest, es);
const immutableRule = await fetchRule(supertest, { ruleId: ELASTIC_SECURITY_RULE_ID });
const hookAction = await createWebHookRuleAction(supertest);
@ -1176,7 +1176,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@skipInQA should show "notifications_enabled" to be "1", "has_notification" to be "true, "has_legacy_notification" to be "false" for rule that has at least "1" action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerlessMKI should show "notifications_enabled" to be "1", "has_notification" to be "true, "has_legacy_notification" to be "false" for rule that has at least "1" action(s) and the alert is "enabled"/"active"', async () => {
await installMockPrebuiltRules(supertest, es);
const immutableRule = await fetchRule(supertest, { ruleId: ELASTIC_SECURITY_RULE_ID });
const hookAction = await createWebHookRuleAction(supertest);
@ -1229,7 +1229,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_disabled" to be "1", "has_notification" to be "false, "has_legacy_notification" to be "true" for rule that has at least "1" action(s) and the alert is "disabled"/"in-active"', async () => {
it('@skipInServerless should show "legacy_notifications_disabled" to be "1", "has_notification" to be "false, "has_legacy_notification" to be "true" for rule that has at least "1" action(s) and the alert is "disabled"/"in-active"', async () => {
await installMockPrebuiltRules(supertest, es);
const immutableRule = await fetchRule(supertest, { ruleId: ELASTIC_SECURITY_RULE_ID });
const hookAction = await createWebHookRuleAction(supertest);
@ -1282,7 +1282,7 @@ export default ({ getService }: FtrProviderContext) => {
});
});
it('@brokenInServerless should show "legacy_notifications_enabled" to be "1", "has_notification" to be "false, "has_legacy_notification" to be "true" for rule that has at least "1" action(s) and the alert is "enabled"/"active"', async () => {
it('@skipInServerless should show "legacy_notifications_enabled" to be "1", "has_notification" to be "false, "has_legacy_notification" to be "true" for rule that has at least "1" action(s) and the alert is "enabled"/"active"', async () => {
await installMockPrebuiltRules(supertest, es);
const immutableRule = await fetchRule(supertest, { ruleId: ELASTIC_SECURITY_RULE_ID });
const hookAction = await createWebHookRuleAction(supertest);

2
x-pack/test/security_solution_api_integration/test_suites/detections_response/user_roles/trial_license_complete_tier/read_privileges.ts
View file

@ -20,7 +20,7 @@ export default ({ getService }: FtrProviderContext) => {
const supertestWithoutAuth = getService('supertestWithoutAuth');
// Failing ES Promotion: https://github.com/elastic/kibana/issues/174028
describe.skip('@ess @serverless @brokenInServerless read_privileges', () => {
describe.skip('@ess @serverless @skipInServerless read_privileges', () => {
it('should return expected privileges for elastic admin', async () => {
const { body } = await supertest.get(DETECTION_ENGINE_PRIVILEGES_URL).send().expect(200);
expect(body).to.eql({

2
x-pack/test/security_solution_api_integration/test_suites/entity_analytics/risk_engine/trial_license_complete_tier/asset_criticality.ts
View file

@ -23,7 +23,7 @@ export default ({ getService }: FtrProviderContext) => {
const supertest = getService('supertest');
const assetCriticalityRoutes = assetCriticalityRouteHelpersFactory(supertest);
describe('@ess @serverless @skipInQA asset_criticality Asset Criticality APIs', () => {
describe('@ess @serverless @skipInServerlessMKI asset_criticality Asset Criticality APIs', () => {
beforeEach(async () => {
await cleanRiskEngine({ kibanaServer, es, log });
await cleanAssetCriticality({ log, es });

10
x-pack/test/security_solution_api_integration/test_suites/entity_analytics/risk_engine/trial_license_complete_tier/risk_scoring_task/task_execution.ts
View file

@ -93,7 +93,7 @@ export default ({ getService }: FtrProviderContext): void => {
await riskEngineRoutes.init();
});
it('@skipInQA calculates and persists risk scores for alert documents', async () => {
it('@skipInServerlessMKI calculates and persists risk scores for alert documents', async () => {
await waitForRiskScoresToBePresent({ es, log, scoreCount: 10 });
const scores = await readRiskScores(es);
@ -104,7 +104,7 @@ export default ({ getService }: FtrProviderContext): void => {
);
});
it('@skipInQA starts the latest transform', async () => {
it('@skipInServerlessMKI starts the latest transform', async () => {
await waitForRiskScoresToBePresent({ es, log, scoreCount: 10 });
const transformStats = await es.transform.getTransformStats({
@ -114,7 +114,7 @@ export default ({ getService }: FtrProviderContext): void => {
expect(transformStats.transforms[0].state).to.eql('started');
});
describe('@skipInQA disabling and re-enabling the risk engine', () => {
describe('@skipInServerlessMKI disabling and re-enabling the risk engine', () => {
beforeEach(async () => {
await waitForRiskScoresToBePresent({ es, log, scoreCount: 10 });
await riskEngineRoutes.disable();
@ -136,7 +136,7 @@ export default ({ getService }: FtrProviderContext): void => {
});
});
describe('@skipInQA disabling the risk engine', () => {
describe('@skipInServerlessMKI disabling the risk engine', () => {
beforeEach(async () => {
await waitForRiskScoresToBePresent({ es, log, scoreCount: 10 });
});
@ -213,7 +213,7 @@ export default ({ getService }: FtrProviderContext): void => {
});
});
it('@skipInQA calculates and persists risk scores for both types of entities', async () => {
it('@skipInServerlessMKI calculates and persists risk scores for both types of entities', async () => {
await riskEngineRoutes.init();
await waitForRiskScoresToBePresent({ es, log, scoreCount: 20 });
const riskScores = await readRiskScores(es);

4
x-pack/test/security_solution_api_integration/test_suites/genai/invoke_ai/trial_license_complete_tier/basic.ts
View file

@ -28,8 +28,8 @@ export default ({ getService }: FtrProviderContext) => {
const objectRemover = new ObjectRemover(supertest);
const configService = getService('config');
// @skipInQA tag because the simulators do not work in the QA env
describe('@ess @serverless @skipInQA Basic Security AI Assistant Invoke AI [non-streaming, non-LangChain]', async () => {
// @skipInServerlessMKI tag because the simulators do not work in the QA env
describe('@ess @serverless @skipInServerlessMKI Basic Security AI Assistant Invoke AI [non-streaming, non-LangChain]', async () => {
after(() => {
objectRemover.removeAll();
});