diff --git a/internal/testrunner/reporters/formats/human.go b/internal/testrunner/reporters/formats/human.go index d271161d8..5fa98f310 100644 --- a/internal/testrunner/reporters/formats/human.go +++ b/internal/testrunner/reporters/formats/human.go @@ -36,6 +36,8 @@ func reportHumanFormat(results []testrunner.TestResult) (string, error) { result = fmt.Sprintf("ERROR: %s", r.ErrorMsg) } else if r.FailureMsg != "" { result = fmt.Sprintf("FAIL: %s", r.FailureMsg) + } else if r.Skipped != nil { + result = r.Skipped.String() } else { result = "PASS" } diff --git a/internal/testrunner/reporters/formats/xunit.go b/internal/testrunner/reporters/formats/xunit.go index f4afb28a0..e2255b0b5 100644 --- a/internal/testrunner/reporters/formats/xunit.go +++ b/internal/testrunner/reporters/formats/xunit.go @@ -33,6 +33,7 @@ type testSuite struct { NumTests int `xml:"tests,attr,omitempty"` NumFailures int `xml:"failures,attr,omitempty"` NumErrors int `xml:"errors,attr,omitempty"` + NumSkipped int `xml:"skipped,attr,omitempty"` Suites []testSuite `xml:"testsuite,omitempty"` Cases []testCase `xml:"testcase,omitempty"` @@ -42,15 +43,20 @@ type testCase struct { ClassName string `xml:"classname,attr"` TimeInSeconds float64 `xml:"time,attr"` - Error string `xml:"error,omitempty"` - Failure string `xml:"failure,omitempty"` + Error string `xml:"error,omitempty"` + Failure string `xml:"failure,omitempty"` + Skipped *skipped `xml:"skipped,omitempty"` +} + +type skipped struct { + Message string `xml:"message,attr"` } func reportXUnitFormat(results []testrunner.TestResult) (string, error) { // test type => package => data stream => test cases tests := map[string]map[string]map[string][]testCase{} - var numTests, numFailures, numErrors int + var numTests, numFailures, numErrors, numSkipped int for _, r := range results { testType := string(r.TestType) if _, exists := tests[testType]; !exists { @@ -79,6 +85,10 @@ func reportXUnitFormat(results []testrunner.TestResult) (string, error) { numErrors++ } + if r.Skipped != nil { + numSkipped++ + } + name := fmt.Sprintf("%s test", r.TestType) if r.Name != "" { name += ": " + r.Name @@ -91,6 +101,11 @@ func reportXUnitFormat(results []testrunner.TestResult) (string, error) { Error: r.ErrorMsg, Failure: failure, } + + if r.Skipped != nil { + c.Skipped = &skipped{r.Skipped.String()} + } + numTests++ tests[testType][r.Package][r.DataStream] = append(tests[testType][r.Package][r.DataStream], c) @@ -107,6 +122,7 @@ func reportXUnitFormat(results []testrunner.TestResult) (string, error) { NumTests: numTests, NumFailures: numFailures, NumErrors: numErrors, + NumSkipped: numSkipped, Cases: make([]testCase, 0), } diff --git a/internal/testrunner/runners/asset/runner.go b/internal/testrunner/runners/asset/runner.go index f0ef40a7d..6b03754b5 100644 --- a/internal/testrunner/runners/asset/runner.go +++ b/internal/testrunner/runners/asset/runner.go @@ -8,7 +8,6 @@ import ( "fmt" "path/filepath" "strings" - "time" es "github.com/elastic/go-elasticsearch/v7" "github.com/pkg/errors" @@ -63,43 +62,39 @@ func (r runner) Run(options testrunner.TestOptions) ([]testrunner.TestResult, er } func (r *runner) run() ([]testrunner.TestResult, error) { - result := testrunner.TestResult{ + result := testrunner.NewResultComposer(testrunner.TestResult{ TestType: TestType, Package: r.testFolder.Package, - } + }) - startTime := time.Now() - resultsWith := func(tr testrunner.TestResult, err error) ([]testrunner.TestResult, error) { - tr.TimeElapsed = time.Now().Sub(startTime) - if err == nil { - return []testrunner.TestResult{tr}, nil - } + testConfig, err := newConfig(r.testFolder.Path) + if err != nil { + return result.WithError(errors.Wrap(err, "unable to load asset loading test config file")) - if tcf, ok := err.(testrunner.ErrTestCaseFailed); ok { - tr.FailureMsg = tcf.Reason - tr.FailureDetails = tcf.Details - return []testrunner.TestResult{tr}, nil - } + } - tr.ErrorMsg = err.Error() - return []testrunner.TestResult{tr}, err + if testConfig != nil && testConfig.Skip != nil { + logger.Warnf("skipping %s test for %s: %s (details: %s)", + TestType, r.testFolder.Package, + testConfig.Skip.Reason, testConfig.Skip.Link.String()) + return result.WithSkip(testConfig.Skip) } pkgManifest, err := packages.ReadPackageManifest(filepath.Join(r.packageRootPath, packages.PackageManifestFile)) if err != nil { - return resultsWith(result, errors.Wrap(err, "reading package manifest failed")) + return result.WithError(errors.Wrap(err, "reading package manifest failed")) } // Install package kib, err := kibana.NewClient() if err != nil { - return resultsWith(result, errors.Wrap(err, "could not create kibana client")) + return result.WithError(errors.Wrap(err, "could not create kibana client")) } logger.Debug("installing package...") actualAssets, err := kib.InstallPackage(*pkgManifest) if err != nil { - return resultsWith(result, errors.Wrap(err, "could not install package")) + return result.WithError(errors.Wrap(err, "could not install package")) } r.removePackageHandler = func() error { logger.Debug("removing package...") @@ -111,26 +106,29 @@ func (r *runner) run() ([]testrunner.TestResult, error) { expectedAssets, err := packages.LoadPackageAssets(r.packageRootPath) if err != nil { - return resultsWith(result, errors.Wrap(err, "could not load expected package assets")) + return result.WithError(errors.Wrap(err, "could not load expected package assets")) } results := make([]testrunner.TestResult, 0, len(expectedAssets)) for _, e := range expectedAssets { - result := testrunner.TestResult{ - Name: fmt.Sprintf("%s %s is loaded", e.Type, e.ID), - Package: pkgManifest.Name, - DataStream: e.DataStream, - TestType: TestType, - TimeElapsed: time.Now().Sub(startTime), - } - + rc := testrunner.NewResultComposer(testrunner.TestResult{ + Name: fmt.Sprintf("%s %s is loaded", e.Type, e.ID), + Package: pkgManifest.Name, + DataStream: e.DataStream, + TestType: TestType, + }) + + var r []testrunner.TestResult if !findActualAsset(actualAssets, e) { - result.FailureMsg = "could not find expected asset" - result.FailureDetails = fmt.Sprintf("could not find %s asset \"%s\". Assets loaded:\n%s", e.Type, e.ID, formatAssetsAsString(actualAssets)) + r, _ = rc.WithError(testrunner.ErrTestCaseFailed{ + Reason: "could not find expected asset", + Details: fmt.Sprintf("could not find %s asset \"%s\". Assets loaded:\n%s", e.Type, e.ID, formatAssetsAsString(actualAssets)), + }) + } else { + r, _ = rc.WithSuccess() } - results = append(results, result) - startTime = time.Now() + results = append(results, r[0]) } return results, nil diff --git a/internal/testrunner/runners/asset/test_config.go b/internal/testrunner/runners/asset/test_config.go new file mode 100644 index 000000000..e182e1419 --- /dev/null +++ b/internal/testrunner/runners/asset/test_config.go @@ -0,0 +1,47 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License; +// you may not use this file except in compliance with the Elastic License. + +package asset + +import ( + "io/ioutil" + "os" + "path/filepath" + + "github.com/elastic/go-ucfg" + "github.com/elastic/go-ucfg/yaml" + "github.com/pkg/errors" + + "github.com/elastic/elastic-package/internal/testrunner" +) + +type testConfig struct { + testrunner.SkippableConfig `config:",inline"` +} + +func newConfig(assetTestFolderPath string) (*testConfig, error) { + configFilePath := filepath.Join(assetTestFolderPath, "config.yml") + + // Test configuration file is optional for asset loading tests. If it + // doesn't exist, we can return early. + if _, err := os.Stat(configFilePath); os.IsNotExist(err) { + return nil, nil + } + + data, err := ioutil.ReadFile(configFilePath) + if err != nil { + return nil, errors.Wrapf(err, "could not load asset loading test configuration file: %s", configFilePath) + } + + var c testConfig + cfg, err := yaml.NewConfig(data, ucfg.PathSep(".")) + if err != nil { + return nil, errors.Wrapf(err, "unable to load asset loading test configuration file: %s", configFilePath) + } + if err := cfg.Unpack(&c); err != nil { + return nil, errors.Wrapf(err, "unable to unpack asset loading test configuration file: %s", configFilePath) + } + + return &c, nil +} diff --git a/internal/testrunner/runners/pipeline/runner.go b/internal/testrunner/runners/pipeline/runner.go index 5a909e898..96d0871a4 100644 --- a/internal/testrunner/runners/pipeline/runner.go +++ b/internal/testrunner/runners/pipeline/runner.go @@ -107,6 +107,16 @@ func (r *runner) run() ([]testrunner.TestResult, error) { } tr.Name = tc.name + if tc.config.Skip != nil { + logger.Warnf("skipping %s test for %s/%s: %s (details: %s)", + TestType, r.options.TestFolder.Package, r.options.TestFolder.DataStream, + tc.config.Skip.Reason, tc.config.Skip.Link.String()) + + tr.Skipped = tc.config.Skip + results = append(results, tr) + continue + } + result, err := simulatePipelineProcessing(r.options.ESClient, entryPipeline, tc) if err != nil { err := errors.Wrap(err, "simulating pipeline processing failed") @@ -170,6 +180,13 @@ func (r *runner) loadTestCaseFile(testCaseFile string) (*testCase, error) { return nil, errors.Wrapf(err, "reading config for test case failed (testCasePath: %s)", testCasePath) } + if config.Skip != nil { + return &testCase{ + name: testCaseFile, + config: &config, + }, nil + } + ext := filepath.Ext(testCaseFile) var entries []json.RawMessage diff --git a/internal/testrunner/runners/pipeline/test_config.go b/internal/testrunner/runners/pipeline/test_config.go index df5c7c3f9..4dda5fefc 100644 --- a/internal/testrunner/runners/pipeline/test_config.go +++ b/internal/testrunner/runners/pipeline/test_config.go @@ -12,11 +12,15 @@ import ( "path/filepath" "github.com/pkg/errors" + + "github.com/elastic/elastic-package/internal/testrunner" ) const configTestSuffix = "-config.json" type testConfig struct { + testrunner.SkippableConfig `config:",inline"` + Multiline *multiline `json:"multiline"` Fields map[string]interface{} `json:"fields"` DynamicFields map[string]string `json:"dynamic_fields"` diff --git a/internal/testrunner/runners/system/runner.go b/internal/testrunner/runners/system/runner.go index 85624e595..e44564609 100644 --- a/internal/testrunner/runners/system/runner.go +++ b/internal/testrunner/runners/system/runner.go @@ -111,53 +111,25 @@ func (r *runner) TearDown() error { return nil } -type resultComposer struct { - testrunner.TestResult - startTime time.Time -} - -func (r *runner) newResult(name string) resultComposer { - return resultComposer{ - TestResult: testrunner.TestResult{ - TestType: TestType, - Name: name, - Package: r.options.TestFolder.Package, - DataStream: r.options.TestFolder.DataStream, - }, - startTime: time.Now(), - } -} - -func (rc *resultComposer) withError(err error) ([]testrunner.TestResult, error) { - rc.TimeElapsed = time.Now().Sub(rc.startTime) - if err == nil { - return []testrunner.TestResult{rc.TestResult}, nil - } - - if tcf, ok := err.(testrunner.ErrTestCaseFailed); ok { - rc.FailureMsg += tcf.Reason - rc.FailureDetails += tcf.Details - return []testrunner.TestResult{rc.TestResult}, nil - } - - rc.ErrorMsg += err.Error() - return []testrunner.TestResult{rc.TestResult}, err -} - -func (rc *resultComposer) withSuccess() ([]testrunner.TestResult, error) { - return rc.withError(nil) +func (r *runner) newResult(name string) *testrunner.ResultComposer { + return testrunner.NewResultComposer(testrunner.TestResult{ + TestType: TestType, + Name: name, + Package: r.options.TestFolder.Package, + DataStream: r.options.TestFolder.DataStream, + }) } func (r *runner) run() (results []testrunner.TestResult, err error) { result := r.newResult("(init)") serviceLogsDir, err := install.ServiceLogsDir() if err != nil { - return result.withError(errors.Wrap(err, "reading service logs directory failed")) + return result.WithError(errors.Wrap(err, "reading service logs directory failed")) } files, err := listConfigFiles(r.options.TestFolder.Path) if err != nil { - return result.withError(errors.Wrap(err, "failed listing test case config files")) + return result.WithError(errors.Wrap(err, "failed listing test case config files")) } for _, cfgFile := range files { var ctxt servicedeployer.ServiceContext @@ -167,9 +139,20 @@ func (r *runner) run() (results []testrunner.TestResult, err error) { ctxt.Test.RunID = createTestRunID() testConfig, err := newConfig(filepath.Join(r.options.TestFolder.Path, cfgFile), ctxt) if err != nil { - return result.withError(errors.Wrapf(err, "unable to load system test case file '%s'", cfgFile)) + return result.WithError(errors.Wrapf(err, "unable to load system test case file '%s'", cfgFile)) + } + + var partial []testrunner.TestResult + if testConfig.Skip == nil { + partial, err = r.runTest(testConfig, ctxt) + } else { + logger.Warnf("skipping %s test for %s/%s: %s (details: %s)", + TestType, r.options.TestFolder.Package, r.options.TestFolder.DataStream, + testConfig.Skip.Reason, testConfig.Skip.Link.String()) + result := r.newResult(testConfig.Name()) + partial, err = result.WithSkip(testConfig.Skip) } - partial, err := r.runTest(testConfig, ctxt) + results = append(results, partial...) if err != nil { return results, err @@ -251,20 +234,20 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext pkgManifest, err := packages.ReadPackageManifestFromPackageRoot(r.options.PackageRootPath) if err != nil { - return result.withError(errors.Wrap(err, "reading package manifest failed")) + return result.WithError(errors.Wrap(err, "reading package manifest failed")) } dataStreamPath, found, err := packages.FindDataStreamRootForPath(r.options.TestFolder.Path) if err != nil { - return result.withError(errors.Wrap(err, "locating data stream root failed")) + return result.WithError(errors.Wrap(err, "locating data stream root failed")) } if !found { - return result.withError(errors.New("data stream root not found")) + return result.WithError(errors.New("data stream root not found")) } dataStreamManifest, err := packages.ReadDataStreamManifest(filepath.Join(dataStreamPath, packages.DataStreamManifestFile)) if err != nil { - return result.withError(errors.Wrap(err, "reading data stream manifest failed")) + return result.WithError(errors.Wrap(err, "reading data stream manifest failed")) } // Setup service. @@ -274,7 +257,7 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext DataStreamRootPath: dataStreamPath, }) if err != nil { - return result.withError(errors.Wrap(err, "could not create service runner")) + return result.WithError(errors.Wrap(err, "could not create service runner")) } if config.Service != "" { @@ -282,7 +265,7 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext } service, err := serviceDeployer.SetUp(ctxt) if err != nil { - return result.withError(errors.Wrap(err, "could not setup service")) + return result.WithError(errors.Wrap(err, "could not setup service")) } ctxt = service.Context() r.shutdownServiceHandler = func() error { @@ -297,13 +280,13 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext // Reload test config with ctx variable substitution. config, err = newConfig(config.Path, ctxt) if err != nil { - return result.withError(errors.Wrap(err, "unable to reload system test case configuration")) + return result.WithError(errors.Wrap(err, "unable to reload system test case configuration")) } // Configure package (single data stream) via Ingest Manager APIs. kib, err := kibana.NewClient() if err != nil { - return result.withError(errors.Wrap(err, "can't create Kibana client")) + return result.WithError(errors.Wrap(err, "can't create Kibana client")) } logger.Debug("creating test policy...") @@ -315,7 +298,7 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext } policy, err := kib.CreatePolicy(p) if err != nil { - return result.withError(errors.Wrap(err, "could not create test policy")) + return result.WithError(errors.Wrap(err, "could not create test policy")) } r.deleteTestPolicyHandler = func() error { logger.Debug("deleting test policy...") @@ -329,16 +312,16 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext ds := createPackageDatastream(*policy, *pkgManifest, *dataStreamManifest, *config) if err := kib.AddPackageDataStreamToPolicy(ds); err != nil { - return result.withError(errors.Wrap(err, "could not add data stream config to policy")) + return result.WithError(errors.Wrap(err, "could not add data stream config to policy")) } // Get enrolled agent ID agents, err := kib.ListAgents() if err != nil { - return result.withError(errors.Wrap(err, "could not list agents")) + return result.WithError(errors.Wrap(err, "could not list agents")) } if agents == nil || len(agents) == 0 { - return result.withError(errors.New("no agents found")) + return result.WithError(errors.New("no agents found")) } agent := agents[0] origPolicy := kibana.Policy{ @@ -349,7 +332,7 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext fieldsValidator, err := fields.CreateValidatorForDataStream(dataStreamPath, fields.WithNumericKeywordFields(config.NumericKeywordFields)) if err != nil { - return result.withError(errors.Wrapf(err, "creating fields validator for data stream failed (path: %s)", dataStreamPath)) + return result.WithError(errors.Wrapf(err, "creating fields validator for data stream failed (path: %s)", dataStreamPath)) } // Delete old data @@ -370,7 +353,7 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext } if err := deleteDataStreamDocs(r.options.ESClient, dataStream); err != nil { - return result.withError(errors.Wrapf(err, "error deleting old data in data stream: %s", dataStream)) + return result.WithError(errors.Wrapf(err, "error deleting old data in data stream: %s", dataStream)) } cleared, err := waitUntilTrue(r.hasNumDocs(dataStream, fieldsValidator, func(n int) bool { @@ -380,13 +363,13 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext if err == nil { err = errors.New("unable to clear previous data") } - return result.withError(err) + return result.WithError(err) } // Assign policy to agent logger.Debug("assigning package data stream to agent...") if err := kib.AssignPolicyToAgent(agent, *policy); err != nil { - return result.withError(errors.Wrap(err, "could not assign policy to agent")) + return result.WithError(errors.Wrap(err, "could not assign policy to agent")) } r.resetAgentPolicyHandler = func() error { logger.Debug("reassigning original policy back to agent...") @@ -399,7 +382,7 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext // Signal to the service that the agent is ready (policy is assigned). if config.ServiceNotifySignal != "" { if err = service.Signal(config.ServiceNotifySignal); err != nil { - return result.withError(errors.Wrap(err, "failed to notify test service")) + return result.WithError(errors.Wrap(err, "failed to notify test service")) } } @@ -410,13 +393,13 @@ func (r *runner) runTest(config *testConfig, ctxt servicedeployer.ServiceContext }), 10*time.Minute) if err != nil { - return result.withError(err) + return result.WithError(err) } if !passed { result.FailureMsg = fmt.Sprintf("could not find hits in %s data stream", dataStream) } - return result.withSuccess() + return result.WithSuccess() } func createPackageDatastream( diff --git a/internal/testrunner/runners/system/test_config.go b/internal/testrunner/runners/system/test_config.go index 1b1ea2944..323951e25 100644 --- a/internal/testrunner/runners/system/test_config.go +++ b/internal/testrunner/runners/system/test_config.go @@ -17,17 +17,21 @@ import ( "github.com/elastic/go-ucfg/yaml" "github.com/elastic/elastic-package/internal/packages" + "github.com/elastic/elastic-package/internal/testrunner" "github.com/elastic/elastic-package/internal/testrunner/runners/system/servicedeployer" ) var systemTestConfigFilePattern = regexp.MustCompile(`^test-([a-z0-9_.-]+)-config.yml$`) type testConfig struct { - Input string `config:"input"` - Service string `config:"service"` - ServiceNotifySignal string `config:"service_notify_signal"` // Signal to send when the agent policy is applied. - Vars map[string]packages.VarValue `config:"vars"` - DataStream struct { + testrunner.SkippableConfig `config:",inline"` + + Input string `config:"input"` + Service string `config:"service"` + ServiceNotifySignal string `config:"service_notify_signal"` // Signal to send when the agent policy is applied. + + Vars map[string]packages.VarValue `config:"vars"` + DataStream struct { Vars map[string]packages.VarValue `config:"vars"` } `config:"data_stream"` diff --git a/internal/testrunner/test_config.go b/internal/testrunner/test_config.go new file mode 100644 index 000000000..2e05c47ef --- /dev/null +++ b/internal/testrunner/test_config.go @@ -0,0 +1,30 @@ +// Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one +// or more contributor license agreements. Licensed under the Elastic License; +// you may not use this file except in compliance with the Elastic License. + +package testrunner + +import ( + "fmt" + "net/url" +) + +// SkipConfig allows a test to be marked as skipped +type SkipConfig struct { + // Reason is the short reason for why this test should be skipped. + Reason string `config:"reason"` + + // Link is a URL where more details about the skipped test can be found. + Link url.URL `config:"url"` +} + +func (s SkipConfig) String() string { + return fmt.Sprintf("%s [%s]", s.Reason, s.Link.String()) +} + +// SkippableConfig is a test configuration that allows skipping. This +// struct is intended for embedding in concrete test configuration structs. +type SkippableConfig struct { + // Skip allows this test to be skipped. + Skip *SkipConfig `config:"skip"` +} diff --git a/internal/testrunner/testrunner.go b/internal/testrunner/testrunner.go index 9ef57b05f..3bca9cf42 100644 --- a/internal/testrunner/testrunner.go +++ b/internal/testrunner/testrunner.go @@ -80,6 +80,54 @@ type TestResult struct { // of the error. An error is when the test cannot complete execution due // to an unexpected runtime error in the test execution. ErrorMsg string + + // If the test was skipped, the reason it was skipped and a link for more + // details. + Skipped *SkipConfig +} + +// ResultComposer wraps a TestResult and provides convenience methods for +// manipulating this TestResult. +type ResultComposer struct { + TestResult + StartTime time.Time +} + +// NewResultComposer returns a new ResultComposer with the StartTime +// initialized to now. +func NewResultComposer(tr TestResult) *ResultComposer { + return &ResultComposer{ + TestResult: tr, + StartTime: time.Now(), + } +} + +// WithError sets an error on the test result wrapped by ResultComposer. +func (rc *ResultComposer) WithError(err error) ([]TestResult, error) { + rc.TimeElapsed = time.Now().Sub(rc.StartTime) + if err == nil { + return []TestResult{rc.TestResult}, nil + } + + if tcf, ok := err.(ErrTestCaseFailed); ok { + rc.FailureMsg += tcf.Reason + rc.FailureDetails += tcf.Details + return []TestResult{rc.TestResult}, nil + } + + rc.ErrorMsg += err.Error() + return []TestResult{rc.TestResult}, err +} + +// WithSuccess marks the test result wrapped by ResultComposer as successful. +func (rc *ResultComposer) WithSuccess() ([]TestResult, error) { + return rc.WithError(nil) +} + +// WithSkip marks the test result wrapped by ResultComposer as skipped. +func (rc *ResultComposer) WithSkip(s *SkipConfig) ([]TestResult, error) { + rc.TestResult.Skipped = s + return rc.WithError(nil) } // TestFolder encapsulates the test folder path and names of the package + data stream diff --git a/test/packages/apache/data_stream/error/_dev/test/system/test-default-config.yml b/test/packages/apache/data_stream/error/_dev/test/system/test-default-config.yml index ec7356ee9..6304ef30f 100644 --- a/test/packages/apache/data_stream/error/_dev/test/system/test-default-config.yml +++ b/test/packages/apache/data_stream/error/_dev/test/system/test-default-config.yml @@ -1,5 +1,10 @@ +skip: + reason: testing skip + link: https://github.com/elastic/integrations/issues/123456789 vars: ~ data_stream: vars: paths: - - "{{SERVICE_LOGS_DIR}}/error.log*" + # This path should cause the test to fail if the skip feature + # stops working as expected. + - "{{SERVICE_LOGS_DIR}}/non-existent.log*"