New Resource: azurerm_scheduler_job

azurerm/config.go

@@ -182,6 +182,10 @@ type ArmClient struct {
 	resourceGroupsClient  resources.GroupsClient
 	subscriptionsClient   subscriptions.Client
 
+	//Scheduler
+	schedulerJobCollectionsClient scheduler.JobCollectionsClient
+	schedulerJobsClient           scheduler.JobsClient
+
 	// Search
 	searchServicesClient search.ServicesClient
 
@@ -192,9 +196,6 @@ type ArmClient struct {
 	serviceBusSubscriptionsClient     servicebus.SubscriptionsClient
 	serviceBusSubscriptionRulesClient servicebus.RulesClient
 
-	//Scheduler
-	schedulerJobCollectionsClient scheduler.JobCollectionsClient
-
 	// Storage
 	storageServiceClient storage.AccountsClient
 	storageUsageClient   storage.UsageClient
@@ -849,6 +850,16 @@ func (c *ArmClient) registerResourcesClients(endpoint, subscriptionId string, au
 	c.subscriptionsClient = subscriptionsClient
 }
 
+func (c *ArmClient) registerSchedulerClients(endpoint, subscriptionId string, auth autorest.Authorizer) {
+	jobCollectionsClient := scheduler.NewJobCollectionsClientWithBaseURI(endpoint, subscriptionId)
+	c.configureClient(&jobCollectionsClient.Client, auth)
+	c.schedulerJobCollectionsClient = jobCollectionsClient
+
+	jobsClient := scheduler.NewJobsClientWithBaseURI(endpoint, subscriptionId)
+	c.configureClient(&jobsClient.Client, auth)
+	c.schedulerJobsClient = jobsClient
+}
+
 func (c *ArmClient) registerSearchClients(endpoint, subscriptionId string, auth autorest.Authorizer) {
 	searchClient := search.NewServicesClientWithBaseURI(endpoint, subscriptionId)
 	c.configureClient(&searchClient.Client, auth)
@@ -877,12 +888,6 @@ func (c *ArmClient) registerServiceBusClients(endpoint, subscriptionId string, a
 	c.serviceBusSubscriptionRulesClient = subscriptionRulesClient
 }
 
-func (c *ArmClient) registerSchedulerClients(endpoint, subscriptionId string, auth autorest.Authorizer) {
-	jobsClient := scheduler.NewJobCollectionsClientWithBaseURI(endpoint, subscriptionId)
-	c.configureClient(&jobsClient.Client, auth)
-	c.schedulerJobCollectionsClient = jobsClient
-}
-
 func (c *ArmClient) registerStorageClients(endpoint, subscriptionId string, auth autorest.Authorizer) {
 	accountsClient := storage.NewAccountsClientWithBaseURI(endpoint, subscriptionId)
 	c.configureClient(&accountsClient.Client, auth)

azurerm/helpers/set/set.go

@@ -0,0 +1,16 @@
+package set
+
+import (
+	"strconv"
+	"strings"
+
+	"github.com/hashicorp/terraform/helper/hashcode"
+)
+
+func HashInt(v interface{}) int {
+	return hashcode.String(strconv.Itoa(v.(int)))
+}
+
+func HashStringIgnoreCase(v interface{}) int {
+	return hashcode.String(strings.ToLower(v.(string)))
+}

azurerm/helpers/supress/suppress.go

@@ -0,0 +1,23 @@
+package supress
+
+import (
+	"time"
+
+	"github.com/hashicorp/terraform/helper/schema"
+	"strings"
+)
+
+func CaseDifference(_, old, new string, _ *schema.ResourceData) bool {
+	return strings.ToLower(old) == strings.ToLower(new)
+}
+
+func Rfc3339Time(_, old, new string, _ *schema.ResourceData) bool {
+	ot, oerr := time.Parse(time.RFC3339, old)
+	nt, nerr := time.Parse(time.RFC3339, new)
+
+	if oerr != nil || nerr != nil {
+		return false
+	}
+
+	return nt.Equal(ot)
+}

azurerm/helpers/supress/suppress_test.go

@@ -0,0 +1,90 @@
+package supress
+
+import (
+	"testing"
+)
+
+func TestInternal_Suppress_CaseDifference(t *testing.T) {
+	cases := []struct {
+		StringA  string
+		StringB  string
+		Suppress bool
+	}{
+		{
+			StringA:  "",
+			StringB:  "",
+			Suppress: true,
+		},
+		{
+			StringA:  "ye old text",
+			StringB:  "",
+			Suppress: false,
+		},
+		{
+			StringA:  "ye old text?",
+			StringB:  "ye different text",
+			Suppress: false,
+		},
+		{
+			StringA:  "ye same text!",
+			StringB:  "ye same text!",
+			Suppress: true,
+		},
+		{
+			StringA:  "ye old text?",
+			StringB:  "Ye OLD texT?",
+			Suppress: true,
+		},
+	}
+
+	for _, tc := range cases {
+		if CaseDifference("test", tc.StringA, tc.StringB, nil) != tc.Suppress {
+			t.Fatalf("Expected CaseDifference to return %t for '%s' == '%s'", tc.Suppress, tc.StringA, tc.StringB)
+		}
+	}
+}
+
+func TestInternal_Supress_Rfc3339Time(t *testing.T) {
+	cases := []struct {
+		TimeA    string
+		TimeB    string
+		Suppress bool
+	}{
+		{
+			TimeA:    "",
+			TimeB:    "",
+			Suppress: false,
+		},
+		{
+			TimeA:    "this is not a time",
+			TimeB:    "neither is this",
+			Suppress: false,
+		},
+		{
+			TimeA:    "2000-01-01T01:23:45+00:00",
+			TimeB:    "that is a valid time",
+			Suppress: false,
+		},
+		{
+			TimeA:    "2000-01-01T01:23:45+00:00",
+			TimeB:    "1984-07-07T01:23:45+00:00",
+			Suppress: false,
+		},
+		{
+			TimeA:    "2000-01-01T01:23:45+00:00",
+			TimeB:    "2000-01-01T01:23:45Z",
+			Suppress: true,
+		},
+		{
+			TimeA:    "2000-01-01T01:23:45-08:00",
+			TimeB:    "2000-01-01T09:23:45Z",
+			Suppress: true,
+		},
+	}
+
+	for _, tc := range cases {
+		if Rfc3339Time("test", tc.TimeA, tc.TimeB, nil) != tc.Suppress {
+			t.Fatalf("Expected Rfc3339Time to return %t for '%s' == '%s'", tc.Suppress, tc.TimeA, tc.TimeB)
+		}
+	}
+}

azurerm/helpers/validate/validate.go

@@ -0,0 +1,66 @@
+package validate
+
+import (
+	"fmt"
+	"net/url"
+	"time"
+
+	"github.com/Azure/go-autorest/autorest/date"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+//todo, now in terraform helper, switch over once vended,
+func Rfc3339Time(i interface{}, k string) (ws []string, errors []error) {
+	v, ok := i.(string)
+	if !ok {
+		errors = append(errors, fmt.Errorf("expected type of %s to be string", k))
+		return
+	}
+
+	if _, err := date.ParseTime(time.RFC3339, v); err != nil {
+		errors = append(errors, fmt.Errorf("%q has the invalid RFC3339 date format %q: %+v", k, i, err))
+	}
+
+	return
+}
+
+func IntBetweenAndNot(min, max, not int) schema.SchemaValidateFunc {
+	return func(i interface{}, k string) (s []string, es []error) {
+		v, ok := i.(int)
+		if !ok {
+			es = append(es, fmt.Errorf("expected type of %s to be int", k))
+			return
+		}
+
+		if v < min || v > max {
+			es = append(es, fmt.Errorf("expected %s to be in the range (%d - %d), got %d", k, min, max, v))
+			return
+		}
+
+		if v == not {
+			es = append(es, fmt.Errorf("expected %s to not be %d, got %d", k, not, v))
+			return
+		}
+
+		return
+	}
+}
+
+func Url(i interface{}, k string) (ws []string, errors []error) {
+	v, ok := i.(string)
+	if !ok {
+		errors = append(errors, fmt.Errorf("expected type of %s to be string", k))
+		return
+	}
+
+	url, err := url.Parse(v)
+	if err != nil {
+		errors = append(errors, fmt.Errorf("%q url is in an invalid format: %q (%+v)", k, i, err))
+	} else if url.Scheme != "http" && url.Scheme != "https" {
+		errors = append(errors, fmt.Errorf("%q url is neither an http or https uri: %q", k, url.Scheme))
+	} else if url.Host == "" {
+		errors = append(errors, fmt.Errorf("%q url has no host: %q", k, url))
+	}
+
+	return
+}

azurerm/helpers/validate/validate_test.go

@@ -0,0 +1,43 @@
+package validate
+
+import "testing"
+
+func TestInternal_ValidateRFC3339Time(t *testing.T) {
+	cases := []struct {
+		Time   string
+		Errors int
+	}{
+		{
+			Time:   "",
+			Errors: 1,
+		},
+		{
+			Time:   "this is not a date",
+			Errors: 1,
+		},
+		{
+			Time:   "2000-01-01",
+			Errors: 1,
+		},
+		{
+			Time:   "2000-01-01T01:23:45",
+			Errors: 1,
+		},
+		{
+			Time:   "2000-01-01T01:23:45Z",
+			Errors: 0,
+		},
+		{
+			Time:   "2000-01-01T01:23:45+00:00",
+			Errors: 0,
+		},
+	}
+
+	for _, tc := range cases {
+		_, errors := Rfc3339Time(tc.Time, "test")
+
+		if len(errors) != tc.Errors {
+			t.Fatalf("Expected Rfc3339Time to have an error for '%s'", tc.Time)
+		}
+	}
+}

azurerm/provider.go

@@ -203,6 +203,7 @@ func Provider() terraform.ResourceProvider {
 			"azurerm_servicebus_topic_authorization_rule": resourceArmServiceBusTopicAuthorizationRule(),
 			"azurerm_snapshot":                            resourceArmSnapshot(),
 			"azurerm_scheduler_job_collection":            resourceArmSchedulerJobCollection(),
+			"azurerm_scheduler_job":                       resourceArmSchedulerJob(),
 			"azurerm_sql_database":                        resourceArmSqlDatabase(),
 			"azurerm_sql_elasticpool":                     resourceArmSqlElasticPool(),
 			"azurerm_sql_firewall_rule":                   resourceArmSqlFirewallRule(),