github.com/myhau/pulumi/pkg/v3@v3.70.2-0.20221116134521-f2775972e587/engine/lifecycletest/analyzer_test.go (about)

     1  package lifecycletest
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"testing"
     7  
     8  	"github.com/blang/semver"
     9  	. "github.com/pulumi/pulumi/pkg/v3/engine"
    10  	"github.com/pulumi/pulumi/pkg/v3/resource/deploy/deploytest"
    11  	"github.com/pulumi/pulumi/sdk/v3/go/common/apitype"
    12  	"github.com/pulumi/pulumi/sdk/v3/go/common/resource/plugin"
    13  	"github.com/stretchr/testify/assert"
    14  )
    15  
    16  type testRequiredPolicy struct {
    17  	name    string
    18  	version string
    19  	config  map[string]*json.RawMessage
    20  }
    21  
    22  func (p *testRequiredPolicy) Name() string {
    23  	return p.name
    24  }
    25  
    26  func (p *testRequiredPolicy) Version() string {
    27  	return p.version
    28  }
    29  
    30  func (p *testRequiredPolicy) Install(_ context.Context) (string, error) {
    31  	return "", nil
    32  }
    33  
    34  func (p *testRequiredPolicy) Config() map[string]*json.RawMessage {
    35  	return p.config
    36  }
    37  
    38  func NewRequiredPolicy(name, version string, config map[string]*json.RawMessage) RequiredPolicy {
    39  	return &testRequiredPolicy{
    40  		name:    name,
    41  		version: version,
    42  		config:  config,
    43  	}
    44  }
    45  
    46  func TestSimpleAnalyzer(t *testing.T) {
    47  	t.Parallel()
    48  
    49  	loaders := []*deploytest.PluginLoader{
    50  		deploytest.NewProviderLoader("pkgA", semver.MustParse("1.0.0"), func() (plugin.Provider, error) {
    51  			return &deploytest.Provider{}, nil
    52  		}),
    53  		deploytest.NewAnalyzerLoader("analyzerA", func(_ *plugin.PolicyAnalyzerOptions) (plugin.Analyzer, error) {
    54  			return &deploytest.Analyzer{}, nil
    55  		}),
    56  	}
    57  
    58  	program := deploytest.NewLanguageRuntime(func(_ plugin.RunInfo, monitor *deploytest.ResourceMonitor) error {
    59  		_, _, _, err := monitor.RegisterResource("pkgA:m:typA", "resA", true)
    60  		assert.NoError(t, err)
    61  		return nil
    62  	})
    63  	host := deploytest.NewPluginHost(nil, nil, program, loaders...)
    64  
    65  	p := &TestPlan{
    66  		Options: UpdateOptions{
    67  			RequiredPolicies: []RequiredPolicy{NewRequiredPolicy("analyzerA", "", nil)},
    68  			Host:             host,
    69  		},
    70  	}
    71  
    72  	project := p.GetProject()
    73  	_, res := TestOp(Update).Run(project, p.GetTarget(t, nil), p.Options, false, p.BackendClient, nil)
    74  	assert.Nil(t, res)
    75  }
    76  
    77  func TestSimpleAnalyzeResourceFailure(t *testing.T) {
    78  	t.Parallel()
    79  
    80  	loaders := []*deploytest.PluginLoader{
    81  		deploytest.NewProviderLoader("pkgA", semver.MustParse("1.0.0"), func() (plugin.Provider, error) {
    82  			return &deploytest.Provider{}, nil
    83  		}),
    84  		deploytest.NewAnalyzerLoader("analyzerA", func(_ *plugin.PolicyAnalyzerOptions) (plugin.Analyzer, error) {
    85  			return &deploytest.Analyzer{
    86  				AnalyzeF: func(r plugin.AnalyzerResource) ([]plugin.AnalyzeDiagnostic, error) {
    87  					return []plugin.AnalyzeDiagnostic{{
    88  						PolicyName:       "always-fails",
    89  						PolicyPackName:   "analyzerA",
    90  						Description:      "a policy that always fails",
    91  						Message:          "a policy failed",
    92  						EnforcementLevel: apitype.Mandatory,
    93  						URN:              r.URN,
    94  					}}, nil
    95  				},
    96  			}, nil
    97  		}),
    98  	}
    99  
   100  	program := deploytest.NewLanguageRuntime(func(_ plugin.RunInfo, monitor *deploytest.ResourceMonitor) error {
   101  		_, _, _, err := monitor.RegisterResource("pkgA:m:typA", "resA", true)
   102  		assert.Error(t, err)
   103  		return nil
   104  	})
   105  	host := deploytest.NewPluginHost(nil, nil, program, loaders...)
   106  
   107  	p := &TestPlan{
   108  		Options: UpdateOptions{
   109  			RequiredPolicies: []RequiredPolicy{NewRequiredPolicy("analyzerA", "", nil)},
   110  			Host:             host,
   111  		},
   112  	}
   113  
   114  	project := p.GetProject()
   115  	_, res := TestOp(Update).Run(project, p.GetTarget(t, nil), p.Options, false, p.BackendClient, nil)
   116  	assert.NotNil(t, res)
   117  }
   118  
   119  func TestSimpleAnalyzeStackFailure(t *testing.T) {
   120  	t.Parallel()
   121  
   122  	loaders := []*deploytest.PluginLoader{
   123  		deploytest.NewProviderLoader("pkgA", semver.MustParse("1.0.0"), func() (plugin.Provider, error) {
   124  			return &deploytest.Provider{}, nil
   125  		}),
   126  		deploytest.NewAnalyzerLoader("analyzerA", func(_ *plugin.PolicyAnalyzerOptions) (plugin.Analyzer, error) {
   127  			return &deploytest.Analyzer{
   128  				AnalyzeStackF: func(rs []plugin.AnalyzerStackResource) ([]plugin.AnalyzeDiagnostic, error) {
   129  					return []plugin.AnalyzeDiagnostic{{
   130  						PolicyName:       "always-fails",
   131  						PolicyPackName:   "analyzerA",
   132  						Description:      "a policy that always fails",
   133  						Message:          "a policy failed",
   134  						EnforcementLevel: apitype.Mandatory,
   135  						URN:              rs[0].URN,
   136  					}}, nil
   137  				},
   138  			}, nil
   139  		}),
   140  	}
   141  
   142  	program := deploytest.NewLanguageRuntime(func(_ plugin.RunInfo, monitor *deploytest.ResourceMonitor) error {
   143  		_, _, _, err := monitor.RegisterResource("pkgA:m:typA", "resA", true)
   144  		assert.NoError(t, err)
   145  		return nil
   146  	})
   147  	host := deploytest.NewPluginHost(nil, nil, program, loaders...)
   148  
   149  	p := &TestPlan{
   150  		Options: UpdateOptions{
   151  			RequiredPolicies: []RequiredPolicy{NewRequiredPolicy("analyzerA", "", nil)},
   152  			Host:             host,
   153  		},
   154  	}
   155  
   156  	project := p.GetProject()
   157  	_, res := TestOp(Update).Run(project, p.GetTarget(t, nil), p.Options, false, p.BackendClient, nil)
   158  	assert.NotNil(t, res)
   159  }