From 399b96b1d2ecaafb0a2d2a0899d5983f2485abf5 Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Fri, 26 Apr 2024 14:11:05 -0400 Subject: [PATCH 1/9] initial addition, need to add version checks --- CHANGELOG.md | 6 ++++++ tfexec/apply.go | 18 ++++++++++++++---- tfexec/apply_test.go | 21 +++++++++++++++++++++ tfexec/options.go | 10 ++++++++++ tfexec/plan.go | 37 +++++++++++++++++++++++-------------- tfexec/plan_test.go | 20 ++++++++++++++++++++ 6 files changed, 94 insertions(+), 18 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index dc0fa167..35374e1c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,9 @@ +# 0.21.0 (Unreleased) + +ENHANCEMENTS: + +- tfexec: Add `-allow-deferral` to `(Terraform).Apply()` and `(Terraform).Plan()` methods ([#TBD](https://github.com/hashicorp/terraform-exec/pull/TBD)) + # 0.20.0 (December 20, 2023) ENHANCEMENTS: diff --git a/tfexec/apply.go b/tfexec/apply.go index 2c5a6d07..aeb2ddd8 100644 --- a/tfexec/apply.go +++ b/tfexec/apply.go @@ -12,10 +12,11 @@ import ( ) type applyConfig struct { - backup string - destroy bool - dirOrPlan string - lock bool + allowDeferral bool + backup string + destroy bool + dirOrPlan string + lock bool // LockTimeout must be a string with time unit, e.g. '10s' lockTimeout string @@ -105,6 +106,10 @@ func (opt *DestroyFlagOption) configureApply(conf *applyConfig) { conf.destroy = opt.destroy } +func (opt *AllowDeferralOption) configureApply(conf *applyConfig) { + conf.allowDeferral = opt.allowDeferral +} + // Apply represents the terraform apply subcommand. func (tf *Terraform) Apply(ctx context.Context, opts ...ApplyOption) error { cmd, err := tf.applyCmd(ctx, opts...) @@ -232,6 +237,11 @@ func (tf *Terraform) buildApplyArgs(ctx context.Context, c applyConfig) ([]strin } } + if c.allowDeferral { + // TODO: add tf.compatibile check here for alpha/pre-release + args = append(args, "-allow-deferral") + } + return args, nil } diff --git a/tfexec/apply_test.go b/tfexec/apply_test.go index 8e2ddeed..c6a8f157 100644 --- a/tfexec/apply_test.go +++ b/tfexec/apply_test.go @@ -89,6 +89,27 @@ func TestApplyCmd(t *testing.T) { "-refresh-only", }, nil, applyCmd) }) + + // TODO: Move to a new test for just alpha builds? + t.Run("allow deferrals during apply", func(t *testing.T) { + applyCmd, err := tf.applyCmd(context.Background(), + AllowDeferral(true), + ) + if err != nil { + t.Fatal(err) + } + + assertCmd(t, []string{ + "apply", + "-no-color", + "-auto-approve", + "-input=false", + "-lock=true", + "-parallelism=10", + "-refresh=true", + "-allow-deferral", + }, nil, applyCmd) + }) } func TestApplyJSONCmd(t *testing.T) { diff --git a/tfexec/options.go b/tfexec/options.go index d783027a..6b337481 100644 --- a/tfexec/options.go +++ b/tfexec/options.go @@ -7,6 +7,16 @@ import ( "encoding/json" ) +// TODO: add doc +type AllowDeferralOption struct { + allowDeferral bool +} + +// TODO: add doc +func AllowDeferral(allowDeferral bool) *AllowDeferralOption { + return &AllowDeferralOption{allowDeferral} +} + // AllowMissingConfigOption represents the -allow-missing-config flag. type AllowMissingConfigOption struct { allowMissingConfig bool diff --git a/tfexec/plan.go b/tfexec/plan.go index 946ce8d0..1fc798e2 100644 --- a/tfexec/plan.go +++ b/tfexec/plan.go @@ -12,20 +12,21 @@ import ( ) type planConfig struct { - destroy bool - dir string - lock bool - lockTimeout string - out string - parallelism int - reattachInfo ReattachInfo - refresh bool - refreshOnly bool - replaceAddrs []string - state string - targets []string - vars []string - varFiles []string + allowDeferral bool + destroy bool + dir string + lock bool + lockTimeout string + out string + parallelism int + reattachInfo ReattachInfo + refresh bool + refreshOnly bool + replaceAddrs []string + state string + targets []string + vars []string + varFiles []string } var defaultPlanOptions = planConfig{ @@ -97,6 +98,10 @@ func (opt *DestroyFlagOption) configurePlan(conf *planConfig) { conf.destroy = opt.destroy } +func (opt *AllowDeferralOption) configurePlan(conf *planConfig) { + conf.allowDeferral = opt.allowDeferral +} + // Plan executes `terraform plan` with the specified options and waits for it // to complete. // @@ -243,6 +248,10 @@ func (tf *Terraform) buildPlanArgs(ctx context.Context, c planConfig) ([]string, args = append(args, "-var", v) } } + if c.allowDeferral { + // TODO: add tf.compatibile check here for alpha/pre-release + args = append(args, "-allow-deferral") + } return args, nil } diff --git a/tfexec/plan_test.go b/tfexec/plan_test.go index b0c404ef..2c211227 100644 --- a/tfexec/plan_test.go +++ b/tfexec/plan_test.go @@ -101,6 +101,26 @@ func TestPlanCmd(t *testing.T) { "-refresh-only", }, nil, planCmd) }) + + // TODO: Move to a new test for just alpha builds? + t.Run("allow deferrals during plan", func(t *testing.T) { + planCmd, err := tf.planCmd(context.Background(), AllowDeferral(true)) + if err != nil { + t.Fatal(err) + } + + assertCmd(t, []string{ + "plan", + "-no-color", + "-input=false", + "-detailed-exitcode", + "-lock-timeout=0s", + "-lock=true", + "-parallelism=10", + "-refresh=true", + "-allow-deferral", + }, nil, planCmd) + }) } func TestPlanJSONCmd(t *testing.T) { From 76dbbc51e068d7f9f2815d20d655f62495b8787f Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 14:40:43 -0400 Subject: [PATCH 2/9] update with version checks --- tfexec/apply.go | 13 ++++++- tfexec/apply_test.go | 53 +++++++++++++++----------- tfexec/internal/testutil/tfcache.go | 3 ++ tfexec/plan.go | 13 ++++++- tfexec/plan_test.go | 51 +++++++++++++++---------- tfexec/version.go | 18 +++++++++ tfexec/version_test.go | 58 +++++++++++++++++++++++++++++ 7 files changed, 166 insertions(+), 43 deletions(-) diff --git a/tfexec/apply.go b/tfexec/apply.go index aeb2ddd8..a5f7a655 100644 --- a/tfexec/apply.go +++ b/tfexec/apply.go @@ -238,7 +238,18 @@ func (tf *Terraform) buildApplyArgs(ctx context.Context, c applyConfig) ([]strin } if c.allowDeferral { - // TODO: add tf.compatibile check here for alpha/pre-release + // Ensure the version is later than 1.9.0 + err := tf.compatible(ctx, tf1_9_0, nil) + if err != nil { + return nil, fmt.Errorf("allow-deferral is an experimental option introduced in Terraform 1.9.0: %w", err) + } + + // Ensure the version has experiments enabled (alpha or dev builds) + err = tf.experimentsEnabled(ctx) + if err != nil { + return nil, fmt.Errorf("allow-deferral is only available in experimental Terraform builds: %w", err) + } + args = append(args, "-allow-deferral") } diff --git a/tfexec/apply_test.go b/tfexec/apply_test.go index c6a8f157..fe0420ad 100644 --- a/tfexec/apply_test.go +++ b/tfexec/apply_test.go @@ -89,27 +89,6 @@ func TestApplyCmd(t *testing.T) { "-refresh-only", }, nil, applyCmd) }) - - // TODO: Move to a new test for just alpha builds? - t.Run("allow deferrals during apply", func(t *testing.T) { - applyCmd, err := tf.applyCmd(context.Background(), - AllowDeferral(true), - ) - if err != nil { - t.Fatal(err) - } - - assertCmd(t, []string{ - "apply", - "-no-color", - "-auto-approve", - "-input=false", - "-lock=true", - "-parallelism=10", - "-refresh=true", - "-allow-deferral", - }, nil, applyCmd) - }) } func TestApplyJSONCmd(t *testing.T) { @@ -171,3 +150,35 @@ func TestApplyJSONCmd(t *testing.T) { }, nil, applyCmd) }) } + +func TestApplyCmd_AllowDeferral(t *testing.T) { + td := t.TempDir() + + tf, err := NewTerraform(td, tfVersion(t, testutil.Alpha_v1_9)) + if err != nil { + t.Fatal(err) + } + + // empty env, to avoid environ mismatch in testing + tf.SetEnv(map[string]string{}) + + t.Run("allow deferrals during apply", func(t *testing.T) { + applyCmd, err := tf.applyCmd(context.Background(), + AllowDeferral(true), + ) + if err != nil { + t.Fatal(err) + } + + assertCmd(t, []string{ + "apply", + "-no-color", + "-auto-approve", + "-input=false", + "-lock=true", + "-parallelism=10", + "-refresh=true", + "-allow-deferral", + }, nil, applyCmd) + }) +} diff --git a/tfexec/internal/testutil/tfcache.go b/tfexec/internal/testutil/tfcache.go index ff9ceb00..82d4ef09 100644 --- a/tfexec/internal/testutil/tfcache.go +++ b/tfexec/internal/testutil/tfcache.go @@ -24,6 +24,9 @@ const ( Latest_v1_1 = "1.1.9" Latest_v1_5 = "1.5.3" Latest_v1_6 = "1.6.0-alpha20230719" + + Beta_v1_8 = "1.8.0-beta1" + Alpha_v1_9 = "1.9.0-alpha20240404" ) const appendUserAgent = "tfexec-testutil" diff --git a/tfexec/plan.go b/tfexec/plan.go index 1fc798e2..2fa4e8b8 100644 --- a/tfexec/plan.go +++ b/tfexec/plan.go @@ -249,7 +249,18 @@ func (tf *Terraform) buildPlanArgs(ctx context.Context, c planConfig) ([]string, } } if c.allowDeferral { - // TODO: add tf.compatibile check here for alpha/pre-release + // Ensure the version is later than 1.9.0 + err := tf.compatible(ctx, tf1_9_0, nil) + if err != nil { + return nil, fmt.Errorf("allow-deferral is an experimental option introduced in Terraform 1.9.0: %w", err) + } + + // Ensure the version has experiments enabled (alpha or dev builds) + err = tf.experimentsEnabled(ctx) + if err != nil { + return nil, fmt.Errorf("allow-deferral is only available in experimental Terraform builds: %w", err) + } + args = append(args, "-allow-deferral") } diff --git a/tfexec/plan_test.go b/tfexec/plan_test.go index 2c211227..e48dbe4b 100644 --- a/tfexec/plan_test.go +++ b/tfexec/plan_test.go @@ -101,26 +101,6 @@ func TestPlanCmd(t *testing.T) { "-refresh-only", }, nil, planCmd) }) - - // TODO: Move to a new test for just alpha builds? - t.Run("allow deferrals during plan", func(t *testing.T) { - planCmd, err := tf.planCmd(context.Background(), AllowDeferral(true)) - if err != nil { - t.Fatal(err) - } - - assertCmd(t, []string{ - "plan", - "-no-color", - "-input=false", - "-detailed-exitcode", - "-lock-timeout=0s", - "-lock=true", - "-parallelism=10", - "-refresh=true", - "-allow-deferral", - }, nil, planCmd) - }) } func TestPlanJSONCmd(t *testing.T) { @@ -198,3 +178,34 @@ func TestPlanJSONCmd(t *testing.T) { }, nil, planCmd) }) } + +func TestPlanCmd_AllowDeferral(t *testing.T) { + td := t.TempDir() + + tf, err := NewTerraform(td, tfVersion(t, testutil.Alpha_v1_9)) + if err != nil { + t.Fatal(err) + } + + // empty env, to avoid environ mismatch in testing + tf.SetEnv(map[string]string{}) + + t.Run("allow deferrals during plan", func(t *testing.T) { + planCmd, err := tf.planCmd(context.Background(), AllowDeferral(true)) + if err != nil { + t.Fatal(err) + } + + assertCmd(t, []string{ + "plan", + "-no-color", + "-input=false", + "-detailed-exitcode", + "-lock-timeout=0s", + "-lock=true", + "-parallelism=10", + "-refresh=true", + "-allow-deferral", + }, nil, planCmd) + }) +} diff --git a/tfexec/version.go b/tfexec/version.go index 4ba4f6ea..5dc2dca7 100644 --- a/tfexec/version.go +++ b/tfexec/version.go @@ -33,6 +33,7 @@ var ( tf1_1_0 = version.Must(version.NewVersion("1.1.0")) tf1_4_0 = version.Must(version.NewVersion("1.4.0")) tf1_6_0 = version.Must(version.NewVersion("1.6.0")) + tf1_9_0 = version.Must(version.NewVersion("1.9.0")) ) // Version returns structured output from the terraform version command including both the Terraform CLI version @@ -180,6 +181,23 @@ func (tf *Terraform) compatible(ctx context.Context, minInclusive *version.Versi return nil } +// experimentsEnabled asserts the cached terraform version has experiments enabled in the executable, and returns a well known error if not. +// +// Experiments are enabled in alpha and (potentially) dev builds of Terraform. +func (tf *Terraform) experimentsEnabled(ctx context.Context) error { + tfv, _, err := tf.Version(ctx, false) + if err != nil { + return err + } + + preRelease := tfv.Prerelease() + if preRelease == "dev" || strings.Contains(preRelease, "alpha") { + return nil + } + + return fmt.Errorf("experiments are not enabled in version %s, as it's not an alpha or dev build", errorVersionString(tfv)) +} + func stripPrereleaseAndMeta(v *version.Version) *version.Version { if v == nil { return nil diff --git a/tfexec/version_test.go b/tfexec/version_test.go index cc057ffe..4d7db857 100644 --- a/tfexec/version_test.go +++ b/tfexec/version_test.go @@ -9,6 +9,7 @@ import ( "fmt" "path/filepath" "runtime" + "strings" "testing" "github.com/google/go-cmp/cmp" @@ -293,3 +294,60 @@ func TestCompatible(t *testing.T) { }) } } + +func TestExperimentsEnabled(t *testing.T) { + testCases := map[string]struct { + tfVersion *version.Version + expectedError error + }{ + "experiments-enabled-in-1.9.0-alpha20240404": { + tfVersion: version.Must(version.NewVersion(testutil.Alpha_v1_9)), + }, + "experiments-disabled-in-1.8.0-beta1": { + tfVersion: version.Must(version.NewVersion(testutil.Beta_v1_8)), + expectedError: errors.New("experiments are not enabled in version 1.8.0-beta1, as it's not an alpha or dev build"), + }, + "experiments-disabled-in-1.5.3": { + tfVersion: version.Must(version.NewVersion(testutil.Latest_v1_5)), + expectedError: errors.New("experiments are not enabled in version 1.5.3, as it's not an alpha or dev build"), + }, + } + for name, testCase := range testCases { + name, testCase := name, testCase + t.Run(name, func(t *testing.T) { + ev := &releases.ExactVersion{ + Product: product.Terraform, + Version: testCase.tfVersion, + } + ev.SetLogger(testutil.TestLogger()) + + ctx := context.Background() + t.Cleanup(func() { ev.Remove(ctx) }) + + tfBinPath, err := ev.Install(ctx) + if err != nil { + t.Fatal(err) + } + + tf, err := NewTerraform(filepath.Dir(tfBinPath), tfBinPath) + if err != nil { + t.Fatal(err) + } + + err = tf.experimentsEnabled(context.Background()) + if err != nil { + if testCase.expectedError == nil { + t.Fatalf("expected no error, got: %s", err) + } + + if !strings.Contains(err.Error(), testCase.expectedError.Error()) { + t.Fatalf("expected error %q, got: %s", testCase.expectedError, err) + } + } + + if err == nil && testCase.expectedError != nil { + t.Fatalf("got no error, expected: %s", testCase.expectedError) + } + }) + } +} From e0fa5cb44659e42682ccc107a5442444da0b9ce4 Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 15:36:23 -0400 Subject: [PATCH 3/9] add docs --- tfexec/options.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tfexec/options.go b/tfexec/options.go index 6b337481..339bf39e 100644 --- a/tfexec/options.go +++ b/tfexec/options.go @@ -7,12 +7,14 @@ import ( "encoding/json" ) -// TODO: add doc +// AllowDeferralOption represents the -allow-deferral flag. This flag is only enabled in +// experimental builds of Terraform. (alpha or built via source with experiments enabled) type AllowDeferralOption struct { allowDeferral bool } -// TODO: add doc +// AllowDeferral represents the -allow-deferral flag. This flag is only enabled in +// experimental builds of Terraform. (alpha or built via source with experiments enabled) func AllowDeferral(allowDeferral bool) *AllowDeferralOption { return &AllowDeferralOption{allowDeferral} } From 52cd37b37c9c8cb631c71f65760b049eda5d3c96 Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 15:40:21 -0400 Subject: [PATCH 4/9] add dashes --- tfexec/apply.go | 4 ++-- tfexec/plan.go | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tfexec/apply.go b/tfexec/apply.go index a5f7a655..7a6ea923 100644 --- a/tfexec/apply.go +++ b/tfexec/apply.go @@ -241,13 +241,13 @@ func (tf *Terraform) buildApplyArgs(ctx context.Context, c applyConfig) ([]strin // Ensure the version is later than 1.9.0 err := tf.compatible(ctx, tf1_9_0, nil) if err != nil { - return nil, fmt.Errorf("allow-deferral is an experimental option introduced in Terraform 1.9.0: %w", err) + return nil, fmt.Errorf("-allow-deferral is an experimental option introduced in Terraform 1.9.0: %w", err) } // Ensure the version has experiments enabled (alpha or dev builds) err = tf.experimentsEnabled(ctx) if err != nil { - return nil, fmt.Errorf("allow-deferral is only available in experimental Terraform builds: %w", err) + return nil, fmt.Errorf("-allow-deferral is only available in experimental Terraform builds: %w", err) } args = append(args, "-allow-deferral") diff --git a/tfexec/plan.go b/tfexec/plan.go index 2fa4e8b8..c2ec1f9e 100644 --- a/tfexec/plan.go +++ b/tfexec/plan.go @@ -252,13 +252,13 @@ func (tf *Terraform) buildPlanArgs(ctx context.Context, c planConfig) ([]string, // Ensure the version is later than 1.9.0 err := tf.compatible(ctx, tf1_9_0, nil) if err != nil { - return nil, fmt.Errorf("allow-deferral is an experimental option introduced in Terraform 1.9.0: %w", err) + return nil, fmt.Errorf("-allow-deferral is an experimental option introduced in Terraform 1.9.0: %w", err) } // Ensure the version has experiments enabled (alpha or dev builds) err = tf.experimentsEnabled(ctx) if err != nil { - return nil, fmt.Errorf("allow-deferral is only available in experimental Terraform builds: %w", err) + return nil, fmt.Errorf("-allow-deferral is only available in experimental Terraform builds: %w", err) } args = append(args, "-allow-deferral") From f6fcad1344bcab16f62bd7180e86539939adab99 Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 15:42:03 -0400 Subject: [PATCH 5/9] remove add space --- tfexec/version.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/tfexec/version.go b/tfexec/version.go index 5dc2dca7..87addd1e 100644 --- a/tfexec/version.go +++ b/tfexec/version.go @@ -181,9 +181,8 @@ func (tf *Terraform) compatible(ctx context.Context, minInclusive *version.Versi return nil } -// experimentsEnabled asserts the cached terraform version has experiments enabled in the executable, and returns a well known error if not. -// -// Experiments are enabled in alpha and (potentially) dev builds of Terraform. +// experimentsEnabled asserts the cached terraform version has experiments enabled in the executable, +// and returns a well known error if not. Experiments are enabled in alpha and (potentially) dev builds of Terraform. func (tf *Terraform) experimentsEnabled(ctx context.Context) error { tfv, _, err := tf.Version(ctx, false) if err != nil { From a93f388c4fcd389c13f0d4c482bbfd45c5707e11 Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 15:58:42 -0400 Subject: [PATCH 6/9] update changelog --- CHANGELOG.md | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 35374e1c..c6f565c2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,7 @@ # 0.21.0 (Unreleased) ENHANCEMENTS: - -- tfexec: Add `-allow-deferral` to `(Terraform).Apply()` and `(Terraform).Plan()` methods ([#TBD](https://github.com/hashicorp/terraform-exec/pull/TBD)) +- tfexec: Add `-allow-deferral` to `(Terraform).Apply()` and `(Terraform).Plan()` methods ([#447](https://github.com/hashicorp/terraform-exec/pull/447)) # 0.20.0 (December 20, 2023) From ce1bfe7c72a3f5fe670738868421d89bd1323c61 Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 16:10:55 -0400 Subject: [PATCH 7/9] add skip for darwin/arm --- tfexec/force_unlock_test.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tfexec/force_unlock_test.go b/tfexec/force_unlock_test.go index 34e3efe6..a124167c 100644 --- a/tfexec/force_unlock_test.go +++ b/tfexec/force_unlock_test.go @@ -5,6 +5,7 @@ package tfexec import ( "context" + "runtime" "testing" "github.com/hashicorp/terraform-exec/tfexec/internal/testutil" @@ -39,6 +40,10 @@ func TestForceUnlockCmd(t *testing.T) { // The optional final positional [DIR] argument is available // until v0.15.0. func TestForceUnlockCmd_pre015(t *testing.T) { + if runtime.GOOS == "darwin" && runtime.GOARCH == "arm64" { + t.Skip("Terraform for darwin/arm64 is not available until v1") + } + td := t.TempDir() tf, err := NewTerraform(td, tfVersion(t, testutil.Latest014)) From 7a332423f7cb4100cdad5955914241dc781988ed Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 16:46:55 -0400 Subject: [PATCH 8/9] increase the timeout --- .github/workflows/tests.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index dc7ea6aa..c3035cfd 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -49,7 +49,7 @@ jobs: name: static-checks (go ${{ matrix.go_version }}) needs: resolve-versions runs-on: ubuntu-latest - timeout-minutes: 10 + timeout-minutes: 20 strategy: fail-fast: false matrix: From a1abb29f777f2fe75e26a6d4e650bc39a5b65036 Mon Sep 17 00:00:00 2001 From: Austin Valle Date: Wed, 1 May 2024 17:43:11 -0400 Subject: [PATCH 9/9] wrong timeout lol --- .github/workflows/tests.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index c3035cfd..ed3cfe0f 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -49,7 +49,7 @@ jobs: name: static-checks (go ${{ matrix.go_version }}) needs: resolve-versions runs-on: ubuntu-latest - timeout-minutes: 20 + timeout-minutes: 10 strategy: fail-fast: false matrix: @@ -80,7 +80,7 @@ jobs: - resolve-versions - static-checks runs-on: ${{ matrix.os }} - timeout-minutes: 10 + timeout-minutes: 20 strategy: fail-fast: false matrix: