Merge pull request #4 from fnaoto/2020-12-21

Add app collaborator.

Author: fnaoto

.env.sample

@@ -0,0 +1,6 @@
+export DG_API_KEY=""
+export DG_USER_NAME=""
+export TF_VAR_app_id=""
+export TF_VAR_owner=""
+export TF_VAR_platform=""
+export TF_VAR_add_user_name=""

.envrc

@@ -0,0 +1,3 @@
+export GO111MODULE=on
+
+source .env

.gitignore

@@ -14,3 +14,14 @@ terraform-provider-deploygate
 
 # Dependency directories (remove the comment below to include it)
 # vendor/
+
+# dotenv
+.env
+
+# log
+crash.log
+
+# terraform
+.terraform
+*.tfstate
+*.tfstate.*

Makefile

@@ -26,12 +26,18 @@ release:
 	GOOS=windows GOARCH=amd64 go build -o ./bin/${BINARY}_${VERSION}_windows_amd64
 
 install: build
-	mkdir -p ~/.terraform.d/plugins/${HOSTNAME}/${NAMESPACE}/${NAME}/${VERSION}/${OS_ARCH}
-	mv ${BINARY} ~/.terraform.d/plugins/${HOSTNAME}/${NAMESPACE}/${NAME}/${VERSION}/${OS_ARCH}
+	mkdir -p ~/.terraform.d/plugins/${OS_ARCH}
+	mv ${BINARY} ~/.terraform.d/plugins/${OS_ARCH}
 
 test: 
 	go test -i $(TEST) || exit 1                                                   
 	echo $(TEST) | xargs -t -n4 go test $(TESTARGS) -timeout=30s -parallel=4                    
 
-testacc: 
+testacc: install
 	TF_ACC=1 go test $(TEST) -v $(TESTARGS) -timeout 120m   
+
+examples: install
+	terraform init examples
+	terraform plan examples
+	terraform apply examples
+	terraform destroy examples

deploygate/config.go

@@ -0,0 +1,24 @@
+package deploygate
+
+import (
+	go_deploygate "github.com/recruit-mp/go-deploygate"
+)
+
+// Config : configuration for deploygate client
+type Config struct {
+	apiKey string
+}
+
+// Client : client for deploygate
+type Client struct {
+	client *go_deploygate.Client
+}
+
+// Client : API Client for deploygate
+func (c *Config) Client() (interface{}, error) {
+	var clnt Client
+
+	client, err := go_deploygate.NewClient(c.apiKey)
+	clnt.client = client
+	return &clnt, err
+}

deploygate/config_test.go

@@ -0,0 +1,19 @@
+package deploygate
+
+import "testing"
+
+func Test_Client(t *testing.T) {
+	config := &Config{
+		apiKey: "api key",
+	}
+
+	client, err := config.Client()
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if client == nil {
+		t.Fatalf("Nil Client.")
+	}
+}

deploygate/data_source_app_collaborator.go

@@ -2,6 +2,7 @@ package deploygate
 
 import (
 	"fmt"
+	"log"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	go_deploygate "github.com/recruit-mp/go-deploygate"
@@ -24,26 +25,77 @@ func dataSourceAppCollaborator() *schema.Resource {
 				Type:     schema.TypeString,
 				Required: true,
 			},
+			"users": {
+				Type:     schema.TypeSet,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": {
+							Type:     schema.TypeString,
+							Optional: true,
+						},
+						"role": {
+							Type:     schema.TypeInt,
+							Optional: true,
+						},
+					},
+				},
+			},
+			"teams": {
+				Type:     schema.TypeSet,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"name": {
+							Type:     schema.TypeString,
+							Optional: true,
+						},
+						"role": {
+							Type:     schema.TypeInt,
+							Optional: true,
+						},
+					},
+				},
+			},
+			"usage": {
+				Type:     schema.TypeMap,
+				Computed: true,
+				Elem:     schema.TypeInt,
+			},
 		},
 	}
 }
 
 func dataSourceAppCollaboratorRead(d *schema.ResourceData, meta interface{}) error {
-	client := go_deploygate.DefaultClient()
+	client := meta.(*Client).client
 
 	owner := d.Get("owner").(string)
 	platform := d.Get("platform").(string)
 	appID := d.Get("app_id").(string)
 
+	log.Printf("[DEBUG] dataSourceAppCollaboratorRead: %s, %s, %s", owner, platform, appID)
+
 	g := &go_deploygate.GetAppCollaboratorInput{
 		Owner:    owner,
 		Platform: platform,
 		AppId:    appID,
 	}
-	collaborator, _ := client.GetAppCollaborator(g)
+
+	collaborator, err := client.GetAppCollaborator(g)
+
+	if err != nil {
+		return err
+	}
+
+	rs := collaborator.Results
+
 	d.SetId(fmt.Sprintf("%s/%s/%s", owner, platform, appID))
-	d.Set("users", collaborator.Results.Users)
-	d.Set("teams", collaborator.Results.Teams)
-	d.Set("usage", collaborator.Results.Usage)
+	d.Set("users", rs.Users)
+	d.Set("teams", rs.Teams)
+	d.Set("usage", map[string]interface{}{
+		"max":  rs.Usage.Max,
+		"used": rs.Usage.Used,
+	})
+
 	return nil
 }

deploygate/data_source_app_collaborator_test.go

@@ -8,48 +8,64 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/v2/terraform"
 )
 
-func TestAppCollaborator_basic(t *testing.T) {
+func Test_DataSourceAppCollaborator_basic(t *testing.T) {
 	resource.ParallelTest(t, resource.TestCase{
-		PreCheck:  func() { testDGPreCheck(t) },
+		PreCheck:  func() { Test_DGPreCheck(t) },
 		Providers: testDGProviders,
 		Steps: []resource.TestStep{
 			{
-				Config: testAppCollaboratorConfig,
+				Config: testDataSourceAppCollaboratorConfig,
 				Check: resource.ComposeTestCheckFunc(
-					testAppCollaborator("data.deploygate_app_collaborator.current"),
+					testDataSourceAppCollaborator("data.deploygate_app_collaborator.current"),
 				),
 			},
 		},
 	})
 }
 
-func testAppCollaborator(n string) resource.TestCheckFunc {
+func testDataSourceAppCollaborator(n string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]
 		if !ok {
 			return fmt.Errorf("Can't find app users resource: %s", n)
 		}
 
 		if rs.Primary.ID == "" {
-			return fmt.Errorf("Account Id resource ID not set")
+			return fmt.Errorf("Resource ID not set")
 		}
 
-		if rs.Primary.Attributes["users"] == "" {
-			return fmt.Errorf("Users expected to not be nil")
+		if rs.Primary.Attributes["owner"] == "" {
+			return fmt.Errorf("owner expected to not be nil")
 		}
 
-		if rs.Primary.Attributes["teams"] == "" {
-			return fmt.Errorf("Teams expected to not be nil")
+		if rs.Primary.Attributes["platform"] == "" {
+			return fmt.Errorf("platform expected to not be nil")
 		}
 
-		if rs.Primary.Attributes["usage"] == "" {
-			return fmt.Errorf("Usage expected to not be nil")
+		if rs.Primary.Attributes["app_id"] == "" {
+			return fmt.Errorf("app_id expected to not be nil")
 		}
 
 		return nil
 	}
 }
 
-const testAppCollaboratorConfig = `
-data "deploygate_app_collaborator" "current" {}
+const testDataSourceAppCollaboratorConfig = `
+data "deploygate_app_collaborator" "current" {
+	owner    = var.owner
+	platform = var.platform
+	app_id   = var.app_id
+}
+
+variable "platform" {
+  type = string
+}
+
+variable "app_id" {
+  type = string
+}
+
+variable "owner" {
+  type = string
+}
 `

deploygate/provider.go

@@ -4,27 +4,53 @@ import (
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 )
 
-// Provider -
+// Provider : terraform provider
 func Provider() *schema.Provider {
-	return &schema.Provider{
+	var p *schema.Provider
+	p = &schema.Provider{
 		Schema: map[string]*schema.Schema{
-			"api_token": &schema.Schema{
+			"api_key": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				Sensitive:   true,
-				DefaultFunc: schema.EnvDefaultFunc("DG_API_TOKEN", nil),
+				DefaultFunc: schema.EnvDefaultFunc("DG_API_KEY", nil),
 			},
-			"user_name": &schema.Schema{
+			"user_name": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				DefaultFunc: schema.EnvDefaultFunc("DG_USER_NAME", nil),
 			},
-			"organization_name": &schema.Schema{
+			"organization_name": {
 				Type:        schema.TypeString,
 				Optional:    true,
 				Sensitive:   true,
 				DefaultFunc: schema.EnvDefaultFunc("DG_ORGANIZATION_NAME", nil),
 			},
 		},
+		DataSourcesMap: map[string]*schema.Resource{
+			"deploygate_app_collaborator": dataSourceAppCollaborator(),
+		},
+		ResourcesMap: map[string]*schema.Resource{
+			"deploygate_app_collaborator": resourceAppCollaborator(),
+		},
+	}
+
+	p.ConfigureFunc = providerConfigure(p)
+	return p
+}
+
+func providerConfigure(p *schema.Provider) schema.ConfigureFunc {
+	return func(d *schema.ResourceData) (interface{}, error) {
+		config := Config{
+			apiKey: d.Get("api_key").(string),
+		}
+
+		meta, err := config.Client()
+
+		if err != nil {
+			return nil, err
+		}
+
+		return meta, nil
 	}
 }

deploygate/provider_test.go

@@ -20,14 +20,14 @@ var testDGProviderConfigure sync.Once
 
 var testDGProviders map[string]*schema.Provider
 
-func testDGPreCheck(t *testing.T) {
+func Test_DGPreCheck(t *testing.T) {
 	testDGProviderConfigure.Do(func() {
-		if os.Getenv("DG_API_TOKEN") == "" || os.Getenv("DG_USER_NAME") == "" {
-			t.Fatal("DG_API_TOKEN and DG_USER_NAME must be set for acceptance tests")
+		if os.Getenv("DG_API_KEY") == "" {
+			t.Fatal("DG_API_KEY must be set for acceptance tests")
 		}
 
-		if os.Getenv("DG_API_TOKEN") == "" || os.Getenv("DG_ORGANIZATION_NAME") == "" {
-			t.Fatal("DG_API_TOKEN and DG_ORGANIZATION_NAME must be set for acceptance tests")
+		if os.Getenv("DG_USER_NAME") == "" && os.Getenv("DG_ORGANIZATION_NAME") == "" {
+			t.Fatal("DG_USER_NAME or DG_ORGANIZATION_NAME must be set for acceptance tests")
 		}
 
 		err := testDGProvider.Configure(context.Background(), terraform.NewResourceConfigRaw(nil))