Merge branch 'master' into context_k8s

Author: remyleone

go.mod

@@ -2,6 +2,7 @@ module github.com/terraform-providers/terraform-provider-scaleway
 
 require (
 	github.com/aws/aws-sdk-go v1.34.32
+	github.com/dnaeon/go-vcr v1.0.1
 	github.com/google/go-cmp v0.5.2
 	github.com/hashicorp/go-retryablehttp v0.6.7
 	github.com/hashicorp/terraform-plugin-sdk/v2 v2.0.3

main.go

@@ -18,14 +18,14 @@ func main() {
 	if debugMode {
 		err := plugin.Debug(context.Background(), "registry.terraform.io/namespace/provider",
 			&plugin.ServeOpts{
-				ProviderFunc: scaleway.Provider(),
+				ProviderFunc: scaleway.Provider(scaleway.DefaultProviderConfig()),
 			})
 		if err != nil {
 			log.Println(err.Error())
 		}
 	} else {
 		plugin.Serve(&plugin.ServeOpts{
-			ProviderFunc: scaleway.Provider(),
+			ProviderFunc: scaleway.Provider(scaleway.DefaultProviderConfig()),
 		})
 	}
 }

scaleway/data_source_account_ssh_key.go

@@ -1,16 +1,18 @@
 package scaleway
 
 import (
+	"context"
 	"fmt"
 
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	account "github.com/scaleway/scaleway-sdk-go/api/account/v2alpha1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
 )
 
 func dataSourceScalewayAccountSSHKey() *schema.Resource {
 	return &schema.Resource{
-		Read: dataSourceScalewayAccountSSHKeyRead,
-
+		ReadContext: dataSourceScalewayAccountSSHKeyRead,
 		Schema: map[string]*schema.Schema{
 			"name": {
 				Type:        schema.TypeString,
@@ -35,29 +37,29 @@ func dataSourceScalewayAccountSSHKey() *schema.Resource {
 	}
 }
 
-func dataSourceScalewayAccountSSHKeyRead(d *schema.ResourceData, m interface{}) error {
+func dataSourceScalewayAccountSSHKeyRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	accountAPI := accountAPI(m)
 
 	var sshKey *account.SSHKey
 	sshKeyID, ok := d.GetOk("ssh_key_id")
 	if ok {
-		res, err := accountAPI.GetSSHKey(&account.GetSSHKeyRequest{SSHKeyID: expandID(sshKeyID)})
+		res, err := accountAPI.GetSSHKey(&account.GetSSHKeyRequest{SSHKeyID: expandID(sshKeyID)}, scw.WithContext(ctx))
 		if err != nil {
-			return err
+			return diag.FromErr(err)
 		}
 		sshKey = res
 	} else {
 		res, err := accountAPI.ListSSHKeys(&account.ListSSHKeysRequest{
 			Name: expandStringPtr(d.Get("name")),
-		})
+		}, scw.WithContext(ctx))
 		if err != nil {
-			return err
+			return diag.FromErr(err)
 		}
 		if len(res.SSHKeys) == 0 {
-			return fmt.Errorf("no SSH Key found with the name %s", d.Get("name"))
+			return diag.FromErr(fmt.Errorf("no SSH Key found with the name %s", d.Get("name")))
 		}
 		if len(res.SSHKeys) > 1 {
-			return fmt.Errorf("%d SSH Keys found with the same name %s", len(res.SSHKeys), d.Get("name"))
+			return diag.FromErr(fmt.Errorf("%d SSH Keys found with the same name %s", len(res.SSHKeys), d.Get("name")))
 		}
 		sshKey = res.SSHKeys[0]
 	}

scaleway/provider.go

@@ -3,6 +3,7 @@ package scaleway
 import (
 	"context"
 	"fmt"
+	"net/http"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
@@ -11,8 +12,20 @@ import (
 	"github.com/scaleway/scaleway-sdk-go/validation"
 )
 
+// Provider config can be used to provide additional config when creating provider.
+type ProviderConfig struct {
+	// Meta can be used to override Meta that will be used by the provider.
+	// This is useful for tests.
+	Meta *Meta
+}
+
+// DefaultProviderConfig return default ProviderConfig struct
+func DefaultProviderConfig() *ProviderConfig {
+	return &ProviderConfig{}
+}
+
 // Provider returns a terraform.ResourceProvider.
-func Provider() plugin.ProviderFunc {
+func Provider(config *ProviderConfig) plugin.ProviderFunc {
 	return func() *schema.Provider {
 		p := &schema.Provider{
 			Schema: map[string]*schema.Schema{
@@ -102,9 +115,16 @@ func Provider() plugin.ProviderFunc {
 
 		p.ConfigureContextFunc = func(ctx context.Context, data *schema.ResourceData) (interface{}, diag.Diagnostics) {
 			terraformVersion := p.TerraformVersion
+
+			// If we provide meta in config use it. This is useful for tests
+			if config.Meta != nil {
+				return config.Meta, nil
+			}
+
 			meta, err := buildMeta(&MetaConfig{
 				providerSchema:   data,
 				terraformVersion: terraformVersion,
+				httpClient:       &http.Client{Transport: newRetryableTransport(http.DefaultTransport)},
 			})
 			if err != nil {
 				return nil, diag.FromErr(err)
@@ -128,12 +148,11 @@ type MetaConfig struct {
 	providerSchema   *schema.ResourceData
 	terraformVersion string
 	forceZone        scw.Zone
+	httpClient       *http.Client
 }
 
 // providerConfigure creates the Meta object containing the SDK client.
 func buildMeta(config *MetaConfig) (*Meta, error) {
-	httpClient := createRetryableHTTPClient(false)
-
 	////
 	// Load Profile
 	////
@@ -158,7 +177,7 @@ func buildMeta(config *MetaConfig) (*Meta, error) {
 	opts := []scw.ClientOption{
 		scw.WithUserAgent(fmt.Sprintf("terraform-provider/%s terraform/%s", version, config.terraformVersion)),
 		scw.WithProfile(profile),
-		scw.WithHTTPClient(httpClient),
+		scw.WithHTTPClient(config.httpClient),
 	}
 
 	scwClient, err := scw.NewClient(opts...)

scaleway/provider_test.go

@@ -1,16 +1,34 @@
 package scaleway
 
 import (
+	"flag"
+	"net/http"
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
 	"testing"
 
+	"github.com/dnaeon/go-vcr/cassette"
+	"github.com/dnaeon/go-vcr/recorder"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
+	"github.com/scaleway/scaleway-sdk-go/strcase"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
-var testAccProviders map[string]*schema.Provider
-var testAccProvider *schema.Provider
+var (
+	// Deprecated
+	testAccProviders map[string]*schema.Provider
+	// Deprecated
+	testAccProvider *schema.Provider
+
+	// UpdateCassettes will update all cassettes of a given test
+	UpdateCassettes = flag.Bool("cassettes", os.Getenv("TF_UPDATE_CASSETTES") == "true", "Record Cassettes")
+)
 
 func init() {
-	p := Provider()()
+	p := Provider(DefaultProviderConfig())()
 	testAccProvider = p
 	version += "-tftest"
 	testAccProviders = map[string]*schema.Provider{
@@ -19,3 +37,83 @@ func init() {
 }
 
 func testAccPreCheck(_ *testing.T) {}
+
+// getTestFilePath returns a valid filename path based on the go test name and suffix. (Take care of non fs friendly char)
+func getTestFilePath(t *testing.T, suffix string) string {
+	specialChars := regexp.MustCompile(`[\\?%*:|"<>. ]`)
+
+	// Replace nested tests separators.
+	fileName := strings.Replace(t.Name(), "/", "-", -1)
+
+	fileName = strcase.ToBashArg(fileName)
+
+	// Replace special characters.
+	fileName = specialChars.ReplaceAllLiteralString(fileName, "") + suffix
+
+	// Remove prefix to simplify
+	fileName = strings.TrimPrefix(fileName, "test-acc-scaleway-")
+
+	return filepath.Join(".", "testdata", fileName)
+}
+
+// getHTTPRecoder creates a new httpClient that records all HTTP requests in a cassette.
+// This cassette is then replayed whenever tests are executed again. This means that once the
+// requests are recorded in the cassette, no more real HTTP requests must be made to run the tests.
+//
+// It is important to add a `defer cleanup()` so the given cassette files are correctly
+// closed and saved after the requests.
+func getHTTPRecoder(t *testing.T, update bool) (client *http.Client, cleanup func(), err error) {
+	recorderMode := recorder.ModeReplaying
+	if update {
+		recorderMode = recorder.ModeRecording
+	}
+
+	// Setup recorder and scw client
+	r, err := recorder.NewAsMode(getTestFilePath(t, ".cassette"), recorderMode, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// Add a filter which removes Authorization headers from all requests:
+	r.AddFilter(func(i *cassette.Interaction) error {
+		delete(i.Request.Headers, "x-auth-token")
+		delete(i.Request.Headers, "X-Auth-Token")
+		return nil
+	})
+
+	return &http.Client{Transport: newRetryableTransport(r)}, func() {
+		assert.NoError(t, r.Stop()) // Make sure recorder is stopped once done with it
+	}, nil
+}
+
+type TestTools struct {
+	T                 *testing.T
+	Meta              *Meta
+	ProviderFactories map[string]func() (*schema.Provider, error)
+	Cleanup           func()
+}
+
+func NewTestTools(t *testing.T) *TestTools {
+	// Create an http client with recording capabilities
+	httpClient, cleanup, err := getHTTPRecoder(t, *UpdateCassettes)
+	require.NoError(t, err)
+
+	// Create meta that will be passed in the provider config
+	meta, err := buildMeta(&MetaConfig{
+		providerSchema:   nil,
+		terraformVersion: "terraform-tests",
+		httpClient:       httpClient,
+	})
+	require.NoError(t, err)
+
+	return &TestTools{
+		T:    t,
+		Meta: meta,
+		ProviderFactories: map[string]func() (*schema.Provider, error){
+			"scaleway": func() (*schema.Provider, error) {
+				return Provider(&ProviderConfig{Meta: meta})(), nil
+			},
+		},
+		Cleanup: cleanup,
+	}
+}

scaleway/resource_account_ssh_key.go

@@ -1,20 +1,23 @@
 package scaleway
 
 import (
+	"context"
 	"strings"
 
+	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	account "github.com/scaleway/scaleway-sdk-go/api/account/v2alpha1"
+	"github.com/scaleway/scaleway-sdk-go/scw"
 )
 
 func resourceScalewayAccountSSKKey() *schema.Resource {
 	return &schema.Resource{
-		Create: resourceScalewayAccountSSHKeyCreate,
-		Read:   resourceScalewayAccountSSHKeyRead,
-		Update: resourceScalewayAccountSSHKeyUpdate,
-		Delete: resourceScalewayAccountSSHKeyDelete,
+		CreateContext: resourceScalewayAccountSSHKeyCreate,
+		ReadContext:   resourceScalewayAccountSSHKeyRead,
+		UpdateContext: resourceScalewayAccountSSHKeyUpdate,
+		DeleteContext: resourceScalewayAccountSSHKeyDelete,
 		Importer: &schema.ResourceImporter{
-			State: schema.ImportStatePassthrough,
+			StateContext: schema.ImportStatePassthroughContext,
 		},
 		Schema: map[string]*schema.Schema{
 			"name": {
@@ -37,35 +40,35 @@ func resourceScalewayAccountSSKKey() *schema.Resource {
 	}
 }
 
-func resourceScalewayAccountSSHKeyCreate(d *schema.ResourceData, m interface{}) error {
+func resourceScalewayAccountSSHKeyCreate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	accountAPI := accountAPI(m)
 
 	res, err := accountAPI.CreateSSHKey(&account.CreateSSHKeyRequest{
 		Name:           d.Get("name").(string),
 		PublicKey:      strings.Trim(d.Get("public_key").(string), "\n"),
 		OrganizationID: expandStringPtr(d.Get("organization_id")),
-	})
+	}, scw.WithContext(ctx))
 	if err != nil {
-		return err
+		return diag.FromErr(err)
 	}
 
 	d.SetId(res.ID)
 
-	return resourceScalewayAccountSSHKeyRead(d, m)
+	return resourceScalewayAccountSSHKeyRead(ctx, d, m)
 }
 
-func resourceScalewayAccountSSHKeyRead(d *schema.ResourceData, m interface{}) error {
+func resourceScalewayAccountSSHKeyRead(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	accountAPI := accountAPI(m)
 
 	res, err := accountAPI.GetSSHKey(&account.GetSSHKeyRequest{
 		SSHKeyID: d.Id(),
-	})
+	}, scw.WithContext(ctx))
 	if err != nil {
 		if is404Error(err) {
 			d.SetId("")
 			return nil
 		}
-		return err
+		return diag.FromErr(err)
 	}
 
 	_ = d.Set("name", res.Name)
@@ -75,30 +78,30 @@ func resourceScalewayAccountSSHKeyRead(d *schema.ResourceData, m interface{}) er
 	return nil
 }
 
-func resourceScalewayAccountSSHKeyUpdate(d *schema.ResourceData, m interface{}) error {
+func resourceScalewayAccountSSHKeyUpdate(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	accountAPI := accountAPI(m)
 
 	if d.HasChange("name") {
 		_, err := accountAPI.UpdateSSHKey(&account.UpdateSSHKeyRequest{
 			SSHKeyID: d.Id(),
 			Name:     expandStringPtr(d.Get("name")),
-		})
+		}, scw.WithContext(ctx))
 		if err != nil {
-			return err
+			return diag.FromErr(err)
 		}
 	}
 
-	return resourceScalewayAccountSSHKeyRead(d, m)
+	return resourceScalewayAccountSSHKeyRead(ctx, d, m)
 }
 
-func resourceScalewayAccountSSHKeyDelete(d *schema.ResourceData, m interface{}) error {
+func resourceScalewayAccountSSHKeyDelete(ctx context.Context, d *schema.ResourceData, m interface{}) diag.Diagnostics {
 	accountAPI := accountAPI(m)
 
 	err := accountAPI.DeleteSSHKey(&account.DeleteSSHKeyRequest{
 		SSHKeyID: d.Id(),
-	})
+	}, scw.WithContext(ctx))
 	if err != nil && !is404Error(err) {
-		return err
+		return diag.FromErr(err)
 	}
 
 	return nil

scaleway/resource_baremetal_server_test.go

@@ -18,9 +18,8 @@ func init() {
 }
 
 func testSweepBaremetalServer(_ string) error {
-	return sweepZones([]scw.Zone{scw.ZoneFrPar2}, func(scwClient *scw.Client) error {
+	return sweepZones([]scw.Zone{scw.ZoneFrPar2}, func(scwClient *scw.Client, zone scw.Zone) error {
 		baremetalAPI := baremetal.NewAPI(scwClient)
-		zone, _ := scwClient.GetDefaultZone()
 		l.Debugf("sweeper: destroying the baremetal server in (%s)", zone)
 		listServers, err := baremetalAPI.ListServers(&baremetal.ListServersRequest{}, scw.WithAllPages())
 		if err != nil {