StateUpgrade cross-tests

[t0yv0]

Build cross-tests for checking that Pulumi and TF handle state upgrades identically.

TF implements state upgraders feature in the SDKv2 that amounts to having providers specify code that modifies state written by previous versions of the provider.

  // Implementation of a single schema version state upgrade.
  type StateUpgrader struct {
          // Version is the version schema that this Upgrader will handle, converting
          // it to Version+1.
          Version int

          // Type describes the schema that this function can upgrade. Type is
          // required to decode the schema if the state was stored in a legacy
          // flatmap format.
          Type cty.Type

          // Upgrade takes the JSON encoded state and the provider meta value, and
          // upgrades the state one single schema version. The provided state is
          // deocded into the default json types using a map[string]interface{}. It
          // is up to the StateUpgradeFunc to ensure that the returned value can be
          // encoded using the new schema.
          Upgrade StateUpgradeFunc
  }

  type StateUpgradeFunc func(ctx context.Context, rawState map[string]interface{}, meta interface{}) (map[string]interface{}, error)

In Go pseudo-code this could look like this:

  s1 := anySchema()
  var s2 func (StateUpgradeFunc) Schema 
  i1 := anyInput(s1)
  var i2 func (StateUpgradeFunc) Inputs

  spy1, spy2 := spyStateUpgradeFunc(), spyStateUpgradeFunc()

  pulumiUp(s1, i1)
  pulumiUp(s2(spy1.fn), i2(spy2.fn))

  tfApply(s1, i1)
  tfApply(s2(spy1.fn), i2(spy2.fn))

  assert.Equalt(t, spy1.args, spy2.args)

Having significant coverage against a range of schemas would help refactor the code with confidence.

[VenelinMartinov]

Partially addressed by #2040