add fat test for subresource data sources

- dry out some dup code

openapi/provider_test.go

@@ -295,6 +295,92 @@ definitions:
 		})
 	})
 
+	Convey("Given a local server that exposes a swagger file containing a terraform compatible data source that has a subresource path", t, func() {
+		swaggerContent := `swagger: "2.0"
+host: "localhost:8443"
+basePath: "/api"
+
+paths:
+  /v1/cdns/{id}/firewalls:
+    get:
+      responses:
+        200:
+          schema:
+            $ref: "#/definitions/ContentDeliveryNetworkV1Collection"
+
+definitions:
+  ContentDeliveryNetworkV1Collection:
+    type: "array"
+    items:
+      $ref: "#/definitions/ContentDeliveryNetworkV1"
+  ContentDeliveryNetworkV1:
+    type: "object"
+    properties:
+      id:
+        type: "string"
+        readOnly: true
+      label:
+        type: "string"`
+
+		swaggerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.Write([]byte(swaggerContent))
+		}))
+
+		Convey("When CreateSchemaProviderWithConfiguration method is called", func() {
+			providerName := "openapi"
+			p := ProviderOpenAPI{ProviderName: providerName}
+			tfProvider, err := p.CreateSchemaProviderFromServiceConfiguration(&ServiceConfigStub{SwaggerURL: swaggerServer.URL})
+
+			Convey("Then the error should be nil", func() {
+				So(err, ShouldBeNil)
+			})
+			Convey("And the provider returned should be configured as expected", func() {
+				So(tfProvider, ShouldNotBeNil)
+				Convey("the provider schema should be the expected one", func() {
+					So(tfProvider.Schema, ShouldNotBeNil)
+				})
+				Convey("the provider dataSource map should contain the cdn resource with the expected configuration", func() {
+					So(tfProvider.DataSourcesMap, ShouldNotBeNil)
+					So(len(tfProvider.DataSourcesMap), ShouldEqual, 1)
+
+					dataSourceName := fmt.Sprintf("%s_cdns_v1_firewalls", providerName)
+					So(tfProvider.DataSourcesMap, ShouldContainKey, dataSourceName)
+					Convey("the provider cdn resource should have the expected schema", func() {
+						So(tfProvider.DataSourcesMap, ShouldContainKey, dataSourceName)
+
+						// check parent id is part of the schema
+
+						assertTerraformSchemaProperty(t, tfProvider.DataSourcesMap[dataSourceName].Schema["cdns_v1_id"], schema.TypeString, true, false)
+
+						// check actual model properties are part of the schema
+						assertDataSourceSchemaProperty(t, tfProvider.DataSourcesMap[dataSourceName].Schema["label"], schema.TypeString)
+
+						// check filter property is in the schema
+						So(tfProvider.DataSourcesMap[dataSourceName].Schema, ShouldContainKey, "filter")
+						So(tfProvider.DataSourcesMap[dataSourceName].Schema["filter"].Type, ShouldEqual, schema.TypeSet)
+						So(tfProvider.DataSourcesMap[dataSourceName].Schema["filter"].Required, ShouldBeFalse)
+						So(tfProvider.DataSourcesMap[dataSourceName].Schema["filter"].Optional, ShouldBeTrue)
+						So(tfProvider.DataSourcesMap[dataSourceName].Schema["filter"].Computed, ShouldBeFalse)
+
+						elements := tfProvider.DataSourcesMap[dataSourceName].Schema["filter"].Elem.(*schema.Resource).Schema
+						So(elements["name"].Type, ShouldEqual, schema.TypeString)
+						So(elements["values"].Type, ShouldEqual, schema.TypeList)
+					})
+					Convey("the provider cdn-datasource data source should have only the READ operation configured", func() {
+						So(tfProvider.DataSourcesMap[dataSourceName].Read, ShouldNotBeNil)
+					})
+
+					Convey("and the provider resource map must be nil as no resources are configured in the swagger", func() {
+						So(tfProvider.ResourcesMap, ShouldBeEmpty)
+					})
+				})
+				Convey("the provider configuration function should not be nil", func() {
+					So(tfProvider.ConfigureFunc, ShouldNotBeNil)
+				})
+			})
+		})
+	})
+
 	Convey("Given a local server that exposes a swagger file containing a terraform compatible resource taht has a model containing nested objects", t, func() {
 		swaggerContent := `swagger: "2.0"
 host: "localhost:8443"
@@ -371,7 +457,7 @@ definitions:
 				So(tfProvider, ShouldNotBeNil)
 				Convey("the provider schema should only include the endpoints property that enables users to override the resource host from the configuration", func() {
 					So(tfProvider.Schema, ShouldNotBeNil)
-					assertTerraformSchemaProperty(tfProvider.Schema, "endpoints", schema.TypeSet, false, false)
+					assertTerraformSchemaProperty(t, tfProvider.Schema["endpoints"], schema.TypeSet, false, false)
 					So(tfProvider.Schema["endpoints"].Elem.(*schema.Resource).Schema, ShouldContainKey, "cdn_v1")
 				})
 				Convey("the provider resource map should contain the cdn resource with the expected configuration", func() {
@@ -382,14 +468,14 @@ definitions:
 						So(tfProvider.ResourcesMap, ShouldNotBeNil)
 						resourceName := fmt.Sprintf("%s_cdn_v1", providerName)
 						So(tfProvider.ResourcesMap, ShouldContainKey, resourceName)
-						assertTerraformSchemaProperty(tfProvider.ResourcesMap[resourceName].Schema, "label", schema.TypeString, true, false)
-						assertTerraformSchemaNestedObjectProperty(tfProvider.ResourcesMap[resourceName].Schema, "object_nested_scheme_property", false, false)
+						assertTerraformSchemaProperty(t, tfProvider.ResourcesMap[resourceName].Schema["label"], schema.TypeString, true, false)
+						assertTerraformSchemaNestedObjectProperty(t, tfProvider.ResourcesMap[resourceName].Schema["object_nested_scheme_property"], false, false)
 						nestedObject := tfProvider.ResourcesMap[resourceName].Schema["object_nested_scheme_property"]
-						assertTerraformSchemaProperty(nestedObject.Elem.(*schema.Resource).Schema, "name", schema.TypeString, false, true)
-						assertTerraformSchemaProperty(nestedObject.Elem.(*schema.Resource).Schema, "object_property", schema.TypeMap, false, false)
+						assertTerraformSchemaProperty(t, nestedObject.Elem.(*schema.Resource).Schema["name"], schema.TypeString, false, true)
+						assertTerraformSchemaProperty(t, nestedObject.Elem.(*schema.Resource).Schema["object_property"], schema.TypeMap, false, false)
 						object := nestedObject.Elem.(*schema.Resource).Schema["object_property"]
-						assertTerraformSchemaProperty(object.Elem.(*schema.Resource).Schema, "account", schema.TypeString, false, false)
-						assertTerraformSchemaProperty(object.Elem.(*schema.Resource).Schema, "read_only", schema.TypeString, false, true)
+						assertTerraformSchemaProperty(t, object.Elem.(*schema.Resource).Schema["account"], schema.TypeString, false, false)
+						assertTerraformSchemaProperty(t, object.Elem.(*schema.Resource).Schema["read_only"], schema.TypeString, false, true)
 					})
 					Convey("the provider cdn resource should have the expected operations configured", func() {
 						So(tfProvider.ResourcesMap[resourceName].Create, ShouldNotBeNil)
@@ -408,26 +494,6 @@ definitions:
 
 }
 
-func assertTerraformSchemaProperty(actualSchema map[string]*schema.Schema, expectedPropertyName string, expectedType schema.ValueType, expectedRequired, expectedComputed bool) {
-	fmt.Printf(">>> Validating '%s' property settings\n", expectedPropertyName)
-	So(actualSchema, ShouldContainKey, expectedPropertyName)
-	property := actualSchema[expectedPropertyName]
-	So(property.Type, ShouldEqual, expectedType)
-	if expectedRequired {
-		So(property.Required, ShouldBeTrue)
-		So(property.Optional, ShouldBeFalse)
-	} else {
-		So(property.Optional, ShouldBeTrue)
-		So(property.Required, ShouldBeFalse)
-	}
-	So(property.Computed, ShouldEqual, expectedComputed)
-}
-
-func assertTerraformSchemaNestedObjectProperty(actualSchema map[string]*schema.Schema, expectedPropertyName string, expectedRequired, expectedComputed bool) {
-	assertTerraformSchemaProperty(actualSchema, expectedPropertyName, schema.TypeList, expectedRequired, expectedComputed)
-	So(actualSchema[expectedPropertyName].MaxItems, ShouldEqual, 1)
-}
-
 func Test_colliding_resource_names(t *testing.T) {
 	makeSwaggerDoc := func(path1, preferredName1, path2, preferredName2 string, markIgnorePath1 bool) string {
 		if path1 == "" {

openapi/test_utils.go

@@ -164,9 +164,23 @@ func initAPISpecFile(swaggerContent string) *os.File {
 }
 
 func assertDataSourceSchemaProperty(t *testing.T, actual *schema.Schema, expectedType schema.ValueType, msgAndArgs ...interface{}) {
+	assertTerraformSchemaProperty(t, actual, expectedType, false, true)
+}
+
+func assertTerraformSchemaNestedObjectProperty(t *testing.T, actual *schema.Schema, expectedRequired, expectedComputed bool, msgAndArgs ...interface{}) {
+	assertTerraformSchemaProperty(t, actual, schema.TypeList, expectedRequired, expectedComputed)
+	assert.Equal(t, 1, actual.MaxItems, msgAndArgs)
+}
+
+func assertTerraformSchemaProperty(t *testing.T, actual *schema.Schema, expectedType schema.ValueType, expectedRequired, expectedComputed bool, msgAndArgs ...interface{}) {
 	assert.NotNil(t, actual, msgAndArgs)
 	assert.Equal(t, expectedType, actual.Type, msgAndArgs)
-	assert.False(t, actual.Required, msgAndArgs)
-	assert.True(t, actual.Optional, msgAndArgs)
-	assert.True(t, actual.Computed, msgAndArgs)
+	if expectedRequired {
+		assert.True(t, actual.Required, msgAndArgs)
+		assert.False(t, actual.Optional, msgAndArgs)
+	} else {
+		assert.True(t, actual.Optional, msgAndArgs)
+		assert.False(t, actual.Required, msgAndArgs)
+	}
+	assert.Equal(t, expectedComputed, actual.Computed, msgAndArgs)
 }