github.com/cycloidio/terraform@v1.1.10-0.20220513142504-76d5c768dc63/providercache/installer_events_test.go (about)

     1  package providercache
     2  
     3  import (
     4  	"github.com/cycloidio/terraform/addrs"
     5  	"github.com/cycloidio/terraform/getproviders"
     6  )
     7  
     8  type testInstallerEventLogItem struct {
     9  	// The name of the event that occurred, using the same names as the
    10  	// fields of InstallerEvents.
    11  	Event string
    12  
    13  	// Most events relate to a specific provider. For the few event types
    14  	// that don't, this will be a zero-value Provider.
    15  	Provider addrs.Provider
    16  
    17  	// The type of Args will vary by event, but it should always be something
    18  	// that can be deterministically compared using the go-cmp package.
    19  	Args interface{}
    20  }
    21  
    22  // installerLogEventsForTests is a test helper that produces an InstallerEvents
    23  // that writes event notifications (*testInstallerEventLogItem values) to
    24  // the given channel as they occur.
    25  //
    26  // The caller must keep reading from the read side of the given channel
    27  // throughout any installer operation using the returned InstallerEvents.
    28  // It's the caller's responsibility to close the channel if needed and
    29  // clean up any goroutines it started to process the events.
    30  //
    31  // The exact sequence of events emitted for an installer operation might
    32  // change in future, if e.g. we introduce new event callbacks to the
    33  // InstallerEvents struct. Tests using this mechanism may therefore need to
    34  // be updated to reflect such changes.
    35  //
    36  // (The channel-based approach here is so that the control flow for event
    37  // processing will belong to the caller and thus it can safely use its
    38  // testing.T object(s) to emit log lines without non-test-case frames in the
    39  // call stack.)
    40  func installerLogEventsForTests(into chan<- *testInstallerEventLogItem) *InstallerEvents {
    41  	return &InstallerEvents{
    42  		PendingProviders: func(reqs map[addrs.Provider]getproviders.VersionConstraints) {
    43  			into <- &testInstallerEventLogItem{
    44  				Event: "PendingProviders",
    45  				Args:  reqs,
    46  			}
    47  		},
    48  		ProviderAlreadyInstalled: func(provider addrs.Provider, selectedVersion getproviders.Version) {
    49  			into <- &testInstallerEventLogItem{
    50  				Event:    "ProviderAlreadyInstalled",
    51  				Provider: provider,
    52  				Args:     selectedVersion,
    53  			}
    54  		},
    55  		BuiltInProviderAvailable: func(provider addrs.Provider) {
    56  			into <- &testInstallerEventLogItem{
    57  				Event:    "BuiltInProviderAvailable",
    58  				Provider: provider,
    59  			}
    60  		},
    61  		BuiltInProviderFailure: func(provider addrs.Provider, err error) {
    62  			into <- &testInstallerEventLogItem{
    63  				Event:    "BuiltInProviderFailure",
    64  				Provider: provider,
    65  				Args:     err.Error(), // stringified to guarantee cmp-ability
    66  			}
    67  		},
    68  		QueryPackagesBegin: func(provider addrs.Provider, versionConstraints getproviders.VersionConstraints, locked bool) {
    69  			into <- &testInstallerEventLogItem{
    70  				Event:    "QueryPackagesBegin",
    71  				Provider: provider,
    72  				Args: struct {
    73  					Constraints string
    74  					Locked      bool
    75  				}{getproviders.VersionConstraintsString(versionConstraints), locked},
    76  			}
    77  		},
    78  		QueryPackagesSuccess: func(provider addrs.Provider, selectedVersion getproviders.Version) {
    79  			into <- &testInstallerEventLogItem{
    80  				Event:    "QueryPackagesSuccess",
    81  				Provider: provider,
    82  				Args:     selectedVersion.String(),
    83  			}
    84  		},
    85  		QueryPackagesFailure: func(provider addrs.Provider, err error) {
    86  			into <- &testInstallerEventLogItem{
    87  				Event:    "QueryPackagesFailure",
    88  				Provider: provider,
    89  				Args:     err.Error(), // stringified to guarantee cmp-ability
    90  			}
    91  		},
    92  		QueryPackagesWarning: func(provider addrs.Provider, warns []string) {
    93  			into <- &testInstallerEventLogItem{
    94  				Event:    "QueryPackagesWarning",
    95  				Provider: provider,
    96  				Args:     warns,
    97  			}
    98  		},
    99  		LinkFromCacheBegin: func(provider addrs.Provider, version getproviders.Version, cacheRoot string) {
   100  			into <- &testInstallerEventLogItem{
   101  				Event:    "LinkFromCacheBegin",
   102  				Provider: provider,
   103  				Args: struct {
   104  					Version   string
   105  					CacheRoot string
   106  				}{version.String(), cacheRoot},
   107  			}
   108  		},
   109  		LinkFromCacheSuccess: func(provider addrs.Provider, version getproviders.Version, localDir string) {
   110  			into <- &testInstallerEventLogItem{
   111  				Event:    "LinkFromCacheSuccess",
   112  				Provider: provider,
   113  				Args: struct {
   114  					Version  string
   115  					LocalDir string
   116  				}{version.String(), localDir},
   117  			}
   118  		},
   119  		LinkFromCacheFailure: func(provider addrs.Provider, version getproviders.Version, err error) {
   120  			into <- &testInstallerEventLogItem{
   121  				Event:    "LinkFromCacheFailure",
   122  				Provider: provider,
   123  				Args: struct {
   124  					Version string
   125  					Error   string
   126  				}{version.String(), err.Error()},
   127  			}
   128  		},
   129  		FetchPackageMeta: func(provider addrs.Provider, version getproviders.Version) {
   130  			into <- &testInstallerEventLogItem{
   131  				Event:    "FetchPackageMeta",
   132  				Provider: provider,
   133  				Args:     version.String(),
   134  			}
   135  		},
   136  		FetchPackageBegin: func(provider addrs.Provider, version getproviders.Version, location getproviders.PackageLocation) {
   137  			into <- &testInstallerEventLogItem{
   138  				Event:    "FetchPackageBegin",
   139  				Provider: provider,
   140  				Args: struct {
   141  					Version  string
   142  					Location getproviders.PackageLocation
   143  				}{version.String(), location},
   144  			}
   145  		},
   146  		FetchPackageSuccess: func(provider addrs.Provider, version getproviders.Version, localDir string, authResult *getproviders.PackageAuthenticationResult) {
   147  			into <- &testInstallerEventLogItem{
   148  				Event:    "FetchPackageSuccess",
   149  				Provider: provider,
   150  				Args: struct {
   151  					Version    string
   152  					LocalDir   string
   153  					AuthResult string
   154  				}{version.String(), localDir, authResult.String()},
   155  			}
   156  		},
   157  		FetchPackageFailure: func(provider addrs.Provider, version getproviders.Version, err error) {
   158  			into <- &testInstallerEventLogItem{
   159  				Event:    "FetchPackageFailure",
   160  				Provider: provider,
   161  				Args: struct {
   162  					Version string
   163  					Error   string
   164  				}{version.String(), err.Error()},
   165  			}
   166  		},
   167  		ProvidersFetched: func(authResults map[addrs.Provider]*getproviders.PackageAuthenticationResult) {
   168  			into <- &testInstallerEventLogItem{
   169  				Event: "ProvidersFetched",
   170  				Args:  authResults,
   171  			}
   172  		},
   173  		HashPackageFailure: func(provider addrs.Provider, version getproviders.Version, err error) {
   174  			into <- &testInstallerEventLogItem{
   175  				Event:    "HashPackageFailure",
   176  				Provider: provider,
   177  				Args: struct {
   178  					Version string
   179  					Error   string
   180  				}{version.String(), err.Error()},
   181  			}
   182  		},
   183  	}
   184  }