From 89675a00c1fd274593f64f0507e8b6c084c4cbaf Mon Sep 17 00:00:00 2001 From: Piotr Cieslak Date: Tue, 21 Oct 2025 10:49:27 +0000 Subject: [PATCH] Moved creating compute instance to the test runner --- e2e_tests/test_runner/test_runner.go | 68 ++++++++- e2e_tests/test_suites/patch/patch.go | 209 ++++++++++++++++----------- 2 files changed, 184 insertions(+), 93 deletions(-) diff --git a/e2e_tests/test_runner/test_runner.go b/e2e_tests/test_runner/test_runner.go index fcba8f2ea..314fb961a 100644 --- a/e2e_tests/test_runner/test_runner.go +++ b/e2e_tests/test_runner/test_runner.go @@ -19,11 +19,19 @@ import ( "context" "fmt" "log" + "path" "regexp" "strings" "sync" "time" + "github.com/GoogleCloudPlatform/osconfig/e2e_tests/compute" + "github.com/GoogleCloudPlatform/osconfig/e2e_tests/config" + gcpclients "github.com/GoogleCloudPlatform/osconfig/e2e_tests/gcp_clients" + testconfig "github.com/GoogleCloudPlatform/osconfig/e2e_tests/test_config" + utils "github.com/GoogleCloudPlatform/osconfig/e2e_tests/utils" + computeApi "google.golang.org/api/compute/v1" + "github.com/GoogleCloudPlatform/compute-image-tools/go/e2e_test_utils/junitxml" ) @@ -36,8 +44,16 @@ type TestRunner struct { // TODO: Unify test suites implementation to use this r TestSuiteName string } +// ComputeInstanceMetadata contains metadata for VM instance creation. +type ComputeInstanceMetadata struct { + Metadata []*computeApi.MetadataItems + MachineType string + Image string + InstanceNamePrefix string +} + // RunTestCase wraps execution of a test case with timeout and retry logic as well as creating a JUnit XML record. -func (tr *TestRunner) RunTestCase(ctx context.Context, tc *junitxml.TestCase, f func(tc *junitxml.TestCase), tests chan *junitxml.TestCase, wg *sync.WaitGroup, logger *log.Logger, regex *regexp.Regexp) { +func (tr *TestRunner) RunTestCase(ctx context.Context, tc *junitxml.TestCase, f func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instName string), tests chan *junitxml.TestCase, wg *sync.WaitGroup, logger *log.Logger, regex *regexp.Regexp, computeInstanceMetadata *ComputeInstanceMetadata) { defer wg.Done() if tc.FilterTestCase(regex) { @@ -45,37 +61,75 @@ func (tr *TestRunner) RunTestCase(ctx context.Context, tc *junitxml.TestCase, f } else { logger.Printf("Running TestCase %q", tc.Name) - runTestCase(ctx, tc, f, tests, wg, logger, regex) + tr.runTestCase(ctx, tc, f, tests, logger, computeInstanceMetadata) // Retry test if failure if tc.Failure != nil { rerunTC := junitxml.NewTestCase(tr.TestSuiteName, strings.TrimPrefix(tc.Name, fmt.Sprintf("[%s] ", tr.TestSuiteName))) logger.Printf("Rerunning TestCase %q", rerunTC.Name) - runTestCase(ctx, rerunTC, f, tests, wg, logger, regex) + tr.runTestCase(ctx, rerunTC, f, tests, logger, computeInstanceMetadata) } } } -func runTestCase(ctx context.Context, tc *junitxml.TestCase, f func(tc *junitxml.TestCase), tests chan *junitxml.TestCase, wg *sync.WaitGroup, logger *log.Logger, regex *regexp.Regexp) { +func (tr *TestRunner) runTestCase(ctx context.Context, tc *junitxml.TestCase, f func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instName string), tests chan *junitxml.TestCase, logger *log.Logger, computeInstanceMetadata *ComputeInstanceMetadata) { ctx, cancel := context.WithTimeout(ctx, timeout) // Timeout applied on single test execution defer cancel() + testProjectConfig := testconfig.GetProject() + zone := testProjectConfig.AcquireZone() + defer testProjectConfig.ReleaseZone(zone) + + instanceName := fmt.Sprintf("%s-%s", computeInstanceMetadata.InstanceNamePrefix, utils.RandString(5)) + inst, err := createComputeInstance(tc, instanceName, computeInstanceMetadata.Image, computeInstanceMetadata.MachineType, zone, computeInstanceMetadata.Metadata, testProjectConfig, logger) + defer inst.Cleanup() + defer inst.RecordSerialOutput(ctx, path.Join(*config.OutDir, tr.TestSuiteName), 1) + + if err != nil { + return + } + select { case <-ctx.Done(): logger.Printf("TestCase %q timed out after %v.", tc.Name, timeout) tc.WriteFailure("Test timed out.") tc.Finish(tests) - case <-runAsync(tc, f): + case <-runAsync(tc, inst, testProjectConfig, instanceName, f): tc.Finish(tests) logger.Printf("TestCase %q finished in %fs", tc.Name, tc.Time) } } -func runAsync(tc *junitxml.TestCase, f func(tc *junitxml.TestCase)) <-chan int { +func runAsync(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instName string, f func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instName string)) <-chan int { resultChan := make(chan int, 1) go func() { - f(tc) + f(tc, inst, testProjectConfig, instName) resultChan <- 1 }() return resultChan } + +func createComputeInstance(tc *junitxml.TestCase, instanceName, image, machineType, zone string, metadata []*computeApi.MetadataItems, testProjectConfig *testconfig.Project, logger *log.Logger) (*compute.Instance, error) { + computeClient, err := gcpclients.GetComputeClient() + if err != nil { + tc.WriteFailure("Error getting compute client: %v", err) + return nil, err + } + + tc.Logf("Creating instance %q with image %q", instanceName, image) + inst, err := utils.CreateComputeInstance(metadata, computeClient, machineType, image, instanceName, testProjectConfig.TestProjectID, zone, testProjectConfig.ServiceAccountEmail, testProjectConfig.ServiceAccountScopes) + + if err != nil { + tc.WriteFailure("Error creating instance: %v", utils.GetStatusFromError(err)) + return nil, err + } + + tc.Logf("Waiting for agent install to complete") + if _, err := inst.WaitForGuestAttributes("osconfig_tests/install_done", 5*time.Second, 25*time.Minute); err != nil { + tc.WriteFailure("Error waiting for osconfig agent install: %v", err) + return nil, err + } + tc.Logf("Agent installed successfully") + + return inst, nil +} diff --git a/e2e_tests/test_suites/patch/patch.go b/e2e_tests/test_suites/patch/patch.go index acfc4cbf4..b8e7a9f33 100644 --- a/e2e_tests/test_suites/patch/patch.go +++ b/e2e_tests/test_suites/patch/patch.go @@ -74,8 +74,17 @@ func TestSuite(ctx context.Context, tswg *sync.WaitGroup, testSuites chan *junit wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[Execute PatchJob] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { runExecutePatchJobTest(ctx, tc, s, nil) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runExecutePatchJobTest(ctx, tc, s, nil, inst, instanceName, testProjectConfig) + } + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // TODO: remove this hack and setup specific test suites for each test type. // We can't test 'old' images with the head image test. @@ -87,10 +96,17 @@ func TestSuite(ctx context.Context, tswg *sync.WaitGroup, testSuites chan *junit tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[PatchJob triggers reboot] [%s]", s.testName)) pc := &osconfigpb.PatchConfig{Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST}} shouldReboot := true - f := func(tc *junitxml.TestCase) { - runRebootPatchTest(ctx, tc, s, pc, shouldReboot) + instanceNamePrefix := fmt.Sprintf("patch-reboot-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runRebootPatchTest(ctx, tc, s, pc, shouldReboot, inst, instanceName, testProjectConfig) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test that PatchConfig_NEVER prevents reboot. @@ -100,8 +116,17 @@ func TestSuite(ctx context.Context, tswg *sync.WaitGroup, testSuites chan *junit tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[PatchJob does not reboot] [%s]", s.testName)) pc := &osconfigpb.PatchConfig{RebootConfig: osconfigpb.PatchConfig_NEVER, Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST}} shouldReboot := false - f := func(tc *junitxml.TestCase) { runRebootPatchTest(ctx, tc, s, pc, shouldReboot) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + instanceNamePrefix := fmt.Sprintf("patch-reboot-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runRebootPatchTest(ctx, tc, s, pc, shouldReboot, inst, instanceName, testProjectConfig) + } + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } } // Test that pre- and post-patch steps run as expected. @@ -110,69 +135,126 @@ func TestSuite(ctx context.Context, tswg *sync.WaitGroup, testSuites chan *junit s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[PatchJob runs pre-step and post-step] [%s]", s.testName)) pc := patchConfigWithPrePostSteps() - f := func(tc *junitxml.TestCase) { runExecutePatchJobTest(ctx, tc, s, pc) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runExecutePatchJobTest(ctx, tc, s, pc, inst, instanceName, testProjectConfig) + } + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test APT specific functionality, this just tests that using these settings doesn't break anything. for _, setup := range aptHeadImageTestSetup() { wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[APT dist-upgrade, excludes] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { - runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST, Excludes: []string{"pkg1", "/pkg2/"}}}) + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST, Excludes: []string{"pkg1", "/pkg2/"}}}, + inst, instanceName, testProjectConfig) + } + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test APT specific functionality, this just tests that using these settings doesn't break anything. for _, setup := range aptHeadImageTestSetup() { wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[APT dist-upgrade, exclusive packages] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { - runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST, ExclusivePackages: []string{"pkg1"}}}) + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST, ExclusivePackages: []string{"pkg1"}}}, + inst, instanceName, testProjectConfig) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test that apt-get patch works even when a package needs to be downgraded for _, setup := range aptDowngradeImageTestSetup() { wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[PatchJob apt-get doesn't fail on downgrades] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { - runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST}}) + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Apt: &osconfigpb.AptSettings{Type: osconfigpb.AptSettings_DIST}}, + inst, instanceName, testProjectConfig) + } + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test YUM specific functionality, this just tests that using these settings doesn't break anything. for _, setup := range yumHeadImageTestSetup() { wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[YUM security, minimal and excludes] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { - runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Yum: &osconfigpb.YumSettings{Security: true, Minimal: true, Excludes: []string{"pkg1", "pkg2", "/pkg3/"}}}) + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Yum: &osconfigpb.YumSettings{Security: true, Minimal: true, Excludes: []string{"pkg1", "pkg2", "/pkg3/"}}}, + inst, instanceName, testProjectConfig) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test YUM exclusive_package updates, this just tests that using these settings doesn't break anything. for _, setup := range yumHeadImageTestSetup() { wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[YUM exclusive patches] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { - runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Yum: &osconfigpb.YumSettings{ExclusivePackages: []string{"pkg1", "pk3"}}}) + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { + runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{Yum: &osconfigpb.YumSettings{ExclusivePackages: []string{"pkg1", "pk3"}}}, + inst, instanceName, testProjectConfig) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test Zypper specific functionality, this just tests that using these settings doesn't break anything. for _, setup := range suseHeadImageTestSetup() { wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[Zypper excludes, WithOptional, WithUpdate, Categories and Severities] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{ - Zypper: &osconfigpb.ZypperSettings{Excludes: []string{"patch-1", "/patch-2/"}, WithOptional: true, WithUpdate: true, Categories: []string{"security", "recommended", "feature"}, Severities: []string{"critical", "important", "moderate", "low"}}}) + Zypper: &osconfigpb.ZypperSettings{Excludes: []string{"patch-1", "/patch-2/"}, WithOptional: true, WithUpdate: true, Categories: []string{"security", "recommended", "feature"}, Severities: []string{"critical", "important", "moderate", "low"}}}, + inst, instanceName, testProjectConfig) } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } // Test Zypper exclusive patches. the test just makes sure that it does not break anything // the actual combination tests is a part of unit test @@ -180,12 +262,19 @@ func TestSuite(ctx context.Context, tswg *sync.WaitGroup, testSuites chan *junit wg.Add(1) s := setup tc := junitxml.NewTestCase(testSuiteName, fmt.Sprintf("[Zypper exclusivePatches] [%s]", s.testName)) - f := func(tc *junitxml.TestCase) { + instanceNamePrefix := fmt.Sprintf("patch-test-%s-%s", path.Base(s.testName), testSuffix) + computeInstanceMetadata := &testrunner.ComputeInstanceMetadata{ + Metadata: s.metadata, + MachineType: s.machineType, + Image: s.image, + InstanceNamePrefix: instanceNamePrefix, + } + f := func(tc *junitxml.TestCase, inst *compute.Instance, testProjectConfig *testconfig.Project, instanceName string) { runExecutePatchJobTest(ctx, tc, s, &osconfigpb.PatchConfig{ - Zypper: &osconfigpb.ZypperSettings{ExclusivePatches: []string{"patch-1"}}}) // there should be no patch run + Zypper: &osconfigpb.ZypperSettings{ExclusivePatches: []string{"patch-1"}}}, inst, instanceName, testProjectConfig) // there should be no patch run } - go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex) + go testRunner.RunTestCase(ctx, tc, f, tests, &wg, logger, testCaseRegex, computeInstanceMetadata) } go func() { @@ -257,33 +346,7 @@ func awaitPatchJob(ctx context.Context, job *osconfigpb.PatchJob, timeout time.D } } -func runExecutePatchJobTest(ctx context.Context, testCase *junitxml.TestCase, testSetup *patchTestSetup, pc *osconfigpb.PatchConfig) { - computeClient, err := gcpclients.GetComputeClient() - if err != nil { - testCase.WriteFailure("Error getting compute client: %v", err) - return - } - - name := fmt.Sprintf("patch-test-%s-%s-%s", path.Base(testSetup.testName), testSuffix, utils.RandString(5)) - testProjectConfig := testconfig.GetProject() - zone := testProjectConfig.AcquireZone() - defer testProjectConfig.ReleaseZone(zone) - testCase.Logf("Creating instance %q with image %q", name, testSetup.image) - inst, err := utils.CreateComputeInstance(testSetup.metadata, computeClient, testSetup.machineType, testSetup.image, name, testProjectConfig.TestProjectID, zone, testProjectConfig.ServiceAccountEmail, testProjectConfig.ServiceAccountScopes) - if err != nil { - testCase.WriteFailure("Error creating instance: %v", utils.GetStatusFromError(err)) - return - } - defer inst.Cleanup() - defer inst.RecordSerialOutput(ctx, path.Join(*config.OutDir, testSuiteName), 1) - - testCase.Logf("Waiting for agent install to complete") - if _, err := inst.WaitForGuestAttributes("osconfig_tests/install_done", 5*time.Second, 25*time.Minute); err != nil { - testCase.WriteFailure("Error waiting for osconfig agent install: %v", err) - return - } - - testCase.Logf("Agent installed successfully") +func runExecutePatchJobTest(ctx context.Context, testCase *junitxml.TestCase, testSetup *patchTestSetup, pc *osconfigpb.PatchConfig, inst *compute.Instance, instanceName string, testProjectConfig *testconfig.Project) { if err := inst.AddMetadata(compute.BuildInstanceMetadataItem("windows-startup-script-ps1", windowsRecordBoot), compute.BuildInstanceMetadataItem("startup-script", linuxRecordBoot)); err != nil { testCase.WriteFailure("Error setting metadata: %v", err) return @@ -299,7 +362,7 @@ func runExecutePatchJobTest(ctx context.Context, testCase *junitxml.TestCase, te req := &osconfigpb.ExecutePatchJobRequest{ Parent: parent, Description: "testing patch job run", - InstanceFilter: &osconfigpb.PatchInstanceFilter{InstanceNamePrefixes: []string{name}}, + InstanceFilter: &osconfigpb.PatchInstanceFilter{InstanceNamePrefixes: []string{instanceName}}, Duration: &duration.Duration{Seconds: int64(testSetup.assertTimeout / time.Second)}, PatchConfig: pc, } @@ -323,33 +386,7 @@ func runExecutePatchJobTest(ctx context.Context, testCase *junitxml.TestCase, te } } -func runRebootPatchTest(ctx context.Context, testCase *junitxml.TestCase, testSetup *patchTestSetup, pc *osconfigpb.PatchConfig, shouldReboot bool) { - computeClient, err := gcpclients.GetComputeClient() - if err != nil { - testCase.WriteFailure("Error getting compute client: %v", err) - return - } - - name := fmt.Sprintf("patch-reboot-%s-%s-%s", path.Base(testSetup.testName), testSuffix, utils.RandString(5)) - testProjectConfig := testconfig.GetProject() - zone := testProjectConfig.AcquireZone() - defer testProjectConfig.ReleaseZone(zone) - testCase.Logf("Creating instance %q with image %q", name, testSetup.image) - inst, err := utils.CreateComputeInstance(testSetup.metadata, computeClient, testSetup.machineType, testSetup.image, name, testProjectConfig.TestProjectID, zone, testProjectConfig.ServiceAccountEmail, testProjectConfig.ServiceAccountScopes) - if err != nil { - testCase.WriteFailure("Error creating instance: %v", utils.GetStatusFromError(err)) - return - } - defer inst.Cleanup() - defer inst.RecordSerialOutput(ctx, path.Join(*config.OutDir, testSuiteName), 1) - - testCase.Logf("Waiting for agent install to complete") - if _, err := inst.WaitForGuestAttributes("osconfig_tests/install_done", 5*time.Second, 25*time.Minute); err != nil { - testCase.WriteFailure("Error waiting for osconfig agent install: %v", err) - return - } - - testCase.Logf("Agent installed successfully") +func runRebootPatchTest(ctx context.Context, testCase *junitxml.TestCase, testSetup *patchTestSetup, pc *osconfigpb.PatchConfig, shouldReboot bool, inst *compute.Instance, instanceName string, testProjectConfig *testconfig.Project) { if err := inst.AddMetadata(compute.BuildInstanceMetadataItem("windows-startup-script-ps1", windowsRecordBoot), compute.BuildInstanceMetadataItem("startup-script", linuxRecordBoot)); err != nil { testCase.WriteFailure("Error setting metadata: %v", err) return @@ -365,7 +402,7 @@ func runRebootPatchTest(ctx context.Context, testCase *junitxml.TestCase, testSe req := &osconfigpb.ExecutePatchJobRequest{ Parent: parent, Description: "testing patch job reboot", - InstanceFilter: &osconfigpb.PatchInstanceFilter{InstanceNamePrefixes: []string{name}}, + InstanceFilter: &osconfigpb.PatchInstanceFilter{InstanceNamePrefixes: []string{instanceName}}, Duration: &duration.Duration{Seconds: int64(testSetup.assertTimeout / time.Second)}, PatchConfig: pc, }