match permissions defaults with API defaults (#243)

* permission schema fixes

* fix api key test

* user test fixes

* match defaults to API

* fixes

* gofmt

* INBOX-2226 workaround

Author: eravin-ns1

ns1/config.go

@@ -7,9 +7,9 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"io/ioutil"
 	"log"
 	"net/http"
+	"net/http/httputil"
 	"os"
 	"strings"
 
@@ -86,39 +86,49 @@ func (c *Config) Client() (*ns1.Client, error) {
 func Logging() ns1.Decorator {
 	return func(d ns1.Doer) ns1.Doer {
 		return ns1.DoerFunc(func(r *http.Request) (*http.Response, error) {
-			log.Printf("[DEBUG] %s: %s %s", r.UserAgent(), r.Method, r.URL)
+			msgs := []string{}
+			msgs = append(msgs, fmt.Sprintf("[DEBUG] HTTP %s: %s %s", r.UserAgent(), r.Method, r.URL))
 			heads := r.Header.Clone()
 			heads["X-Nsone-Key"] = []string{"<redacted>"}
-			log.Printf("[DEBUG] Headers: %s", heads)
+			msgs = append(msgs, fmt.Sprintf("[DEBUG] HTTP Headers: %s", heads))
 			var err error
 			if r.Body != nil {
-				r.Body, err = logRequest(r.Body)
+				var bodymsg string
+				r.Body, err, bodymsg = logRequest(r.Body)
 				if err != nil {
 					return nil, err
 				}
+				msgs = append(msgs, bodymsg)
 			}
-			return d.Do(r)
+			response, rerr := d.Do(r)
+			dump, _ := httputil.DumpResponse(response, true)
+			for _, m := range msgs {
+				log.Printf(m)
+			}
+			log.Printf("[DEBUG] HTTP Response: %s", dump)
+			return response, rerr
 		})
 	}
 }
 
 // logRequest logs a HTTP request and returns a copy that can be read again
-func logRequest(original io.ReadCloser) (io.ReadCloser, error) {
+func logRequest(original io.ReadCloser) (io.ReadCloser, error, string) {
 	// Handle request contentType
 	var bs bytes.Buffer
 	defer original.Close()
 
 	_, err := io.Copy(&bs, original)
 	if err != nil {
-		return nil, err
+		return nil, err, ""
 	}
 
+	msg := ""
 	debugInfo, err := formatJSON(bs.Bytes())
 	if err == nil {
-		log.Printf("[DEBUG] Request Body: %s", debugInfo)
+		msg = fmt.Sprintf("[DEBUG] HTTP Request Body: %s", debugInfo)
 	}
 
-	return ioutil.NopCloser(strings.NewReader(bs.String())), nil
+	return io.NopCloser(strings.NewReader(bs.String())), nil, msg
 }
 
 // formatJSON attempts to format a byte slice as indented JSON for pretty printing

ns1/permissions.go

@@ -155,37 +155,37 @@ func addPermsSchema(s map[string]*schema.Schema) map[string]*schema.Schema {
 	s["security_manage_global_2fa"] = &schema.Schema{
 		Type:             schema.TypeBool,
 		Optional:         true,
-		Default:          false,
+		Default:          true,
 		DiffSuppressFunc: suppressPermissionDiff,
 	}
 	s["security_manage_active_directory"] = &schema.Schema{
 		Type:             schema.TypeBool,
 		Optional:         true,
-		Computed:         true,
+		Default:          true,
 		DiffSuppressFunc: suppressPermissionDiff,
 	}
 	s["dhcp_manage_dhcp"] = &schema.Schema{
 		Type:             schema.TypeBool,
 		Optional:         true,
-		Computed:         true,
+		Default:          true,
 		DiffSuppressFunc: suppressPermissionDiff,
 	}
 	s["dhcp_view_dhcp"] = &schema.Schema{
 		Type:             schema.TypeBool,
 		Optional:         true,
-		Computed:         true,
+		Default:          true,
 		DiffSuppressFunc: suppressPermissionDiff,
 	}
 	s["ipam_manage_ipam"] = &schema.Schema{
 		Type:             schema.TypeBool,
 		Optional:         true,
-		Computed:         true,
+		Default:          true,
 		DiffSuppressFunc: suppressPermissionDiff,
 	}
 	s["ipam_view_ipam"] = &schema.Schema{
 		Type:             schema.TypeBool,
 		Optional:         true,
-		Computed:         true,
+		Default:          true,
 		DiffSuppressFunc: suppressPermissionDiff,
 	}
 	return s
@@ -354,28 +354,28 @@ func resourceDataToPermissions(d *schema.ResourceData) account.PermissionsMap {
 	if v, ok := d.GetOk("security_manage_active_directory"); ok {
 		p.Security.ManageActiveDirectory = v.(bool)
 	}
-	if v, ok := d.GetOk("dhcp_manage_dhcp"); ok {
-		if p.DHCP == nil {
+	for _, thing := range []string{"dhcp_manage_dhcp", "dhcp_view_dhcp"} {
+		_, ok := d.GetOkExists(thing)
+		if d.HasChange(thing) || ok {
 			p.DHCP = &account.PermissionsDHCP{}
 		}
+	}
+	if v, ok := d.GetOk("dhcp_manage_dhcp"); ok {
 		p.DHCP.ManageDHCP = v.(bool)
 	}
 	if v, ok := d.GetOk("dhcp_view_dhcp"); ok {
-		if p.DHCP == nil {
-			p.DHCP = &account.PermissionsDHCP{}
-		}
 		p.DHCP.ViewDHCP = v.(bool)
 	}
-	if v, ok := d.GetOk("ipam_manage_ipam"); ok {
-		if p.IPAM == nil {
+	for _, thing := range []string{"ipam_manage_ipam", "ipam_view_ipam"} {
+		_, ok := d.GetOkExists(thing)
+		if d.HasChange(thing) || ok {
 			p.IPAM = &account.PermissionsIPAM{}
 		}
+	}
+	if v, ok := d.GetOk("ipam_manage_ipam"); ok {
 		p.IPAM.ManageIPAM = v.(bool)
 	}
 	if v, ok := d.GetOk("ipam_view_ipam"); ok {
-		if p.IPAM == nil {
-			p.IPAM = &account.PermissionsIPAM{}
-		}
 		p.IPAM.ViewIPAM = v.(bool)
 	}
 	return p

ns1/resource_team.go

@@ -111,7 +111,9 @@ func TeamCreate(d *schema.ResourceData, meta interface{}) error {
 	if resp, err := client.Teams.Create(&t); err != nil {
 		return ConvertToNs1Error(resp, err)
 	}
-	return teamToResourceData(d, &t)
+	// workaround INBOX-2226 - send a GET to refresh object
+	_ = teamToResourceData(d, &t)
+	return TeamRead(d, meta)
 }
 
 // TeamRead reads the team data from ns1

ns1/resource_user_test.go

@@ -123,6 +123,7 @@ func TestAccUser_permissions(t *testing.T) {
 					resource.TestCheckResourceAttr("ns1_user.u", "account_manage_account_settings", "false"),
 					resource.TestCheckResourceAttr("ns1_user.u", "account_manage_ip_whitelist", "true"),
 					resource.TestCheckResourceAttr("ns1_user.u", "security_manage_global_2fa", "false"),
+					resource.TestCheckResourceAttr("ns1_user.u", "security_manage_active_directory", "true"),
 				),
 			},
 			{