snyk · eliecharra · Oct 21, 2021 · Oct 19, 2021
@@ -52,4 +52,5 @@ require (
 	google.golang.org/api v0.54.0
 	google.golang.org/genproto v0.0.0-20210813162853-db860fec028c
 	google.golang.org/grpc v1.39.1
+	google.golang.org/protobuf v1.27.1
 )
@@ -340,6 +340,7 @@ func TestTerraformStateReader_Google_Resources(t *testing.T) {
 		{name: "DNS managed zone", dirName: "google_dns_managed_zone", wantErr: false},
 		{name: "bigquery dataset", dirName: "google_bigquery_dataset", wantErr: false},
 		{name: "bigquery table", dirName: "google_bigquery_table", wantErr: false},
+		{name: "compute address", dirName: "google_compute_address", wantErr: false},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

@@ -0,0 +1,22 @@
+[
+ {
+  "Id": "projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address",
+  "Type": "google_compute_address",
+  "Attrs": {
+   "address": "34.136.69.225",
+   "address_type": "EXTERNAL",
+   "creation_timestamp": "2021-10-19T02:29:32.175-07:00",
+   "description": "",
+   "id": "projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address",
+   "name": "my-address",
+   "network": "",
+   "network_tier": "PREMIUM",
+   "prefix_length": 0,
+   "project": "cloudskiff-dev-elie",
+   "purpose": "",
+   "region": "us-central1",
+   "self_link": "https://www.googleapis.com/compute/v1/projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address",
+   "subnetwork": ""
+  }
+ }
+]
@@ -0,0 +1,40 @@
+{
+  "version": 4,
+  "terraform_version": "0.15.5",
+  "serial": 19,
+  "lineage": "80058dbf-c946-85c8-ad1c-165fad8cf85e",
+  "outputs": {},
+  "resources": [
+    {
+      "mode": "managed",
+      "type": "google_compute_address",
+      "name": "ip_address",
+      "provider": "provider[\"registry.terraform.io/hashicorp/google\"]",
+      "instances": [
+        {
+          "schema_version": 0,
+          "attributes": {
+            "address": "34.136.69.225",
+            "address_type": "EXTERNAL",
+            "creation_timestamp": "2021-10-19T02:29:32.175-07:00",
+            "description": "",
+            "id": "projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address",
+            "name": "my-address",
+            "network": "",
+            "network_tier": "PREMIUM",
+            "prefix_length": 0,
+            "project": "cloudskiff-dev-elie",
+            "purpose": "",
+            "region": "us-central1",
+            "self_link": "https://www.googleapis.com/compute/v1/projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address",
+            "subnetwork": "",
+            "timeouts": null,
+            "users": []
+          },
+          "sensitive_attributes": [],
+          "private": "eyJlMmJmYjczMC1lY2FhLTExZTYtOGY4OC0zNDM2M2JjN2M0YzAiOnsiY3JlYXRlIjoyNDAwMDAwMDAwMDAsImRlbGV0ZSI6MjQwMDAwMDAwMDAwfX0="
+        }
+      ]
+    }
+  ]
+}
@@ -0,0 +1,54 @@
+package google
+
 import (
+	remoteerror "github.com/cloudskiff/driftctl/pkg/remote/error"
+	"github.com/cloudskiff/driftctl/pkg/remote/google/repository"
+	"github.com/cloudskiff/driftctl/pkg/resource"
+	"github.com/cloudskiff/driftctl/pkg/resource/google"
+)
+
+type GoogleComputeAddressEnumerator struct {
+	repository repository.AssetRepository
+	factory    resource.ResourceFactory
+}
+
+func NewGoogleComputeAddressEnumerator(repo repository.AssetRepository, factory resource.ResourceFactory) *GoogleComputeAddressEnumerator {
+	return &GoogleComputeAddressEnumerator{
+		repository: repo,
+		factory:    factory,
+	}
+}
+
+func (e *GoogleComputeAddressEnumerator) SupportedType() resource.ResourceType {
+	return google.GoogleComputeAddressResourceType
+}
+
+func (e *GoogleComputeAddressEnumerator) Enumerate() ([]*resource.Resource, error) {
+	resources, err := e.repository.SearchAllAddresses()
+
+	if err != nil {
+		return nil, remoteerror.NewResourceListingError(err, string(e.SupportedType()))
+	}
+
+	results := make([]*resource.Resource, 0, len(resources))
+
+	for _, res := range resources {
+		address := ""
+		if addr, exist := res.GetAdditionalAttributes().GetFields()["address"]; exist {
+			address = addr.GetStringValue()
+		}
+		results = append(
+			results,
+			e.factory.CreateAbstractResource(
+				string(e.SupportedType()),
+				trimResourceName(res.GetName()),
+				map[string]interface{}{
+					"name":    res.GetDisplayName(),
+					"address": address,
+				},
+			),
+		)
+	}
+
+	return results, err
+}
@@ -85,6 +85,8 @@ func Init(version string, alerter *alerter.Alerter,
 	remoteLibrary.AddEnumerator(NewGoogleBigqueryDatasetEnumerator(assetRepository, factory))
 	remoteLibrary.AddEnumerator(NewGoogleBigqueryTableEnumerator(assetRepository, factory))
 
+	remoteLibrary.AddEnumerator(NewGoogleComputeAddressEnumerator(assetRepository, factory))
+
 	err = resourceSchemaRepository.Init(terraform.GOOGLE, provider.Version(), provider.Schema())
 	if err != nil {
 		return err

@@ -22,6 +22,7 @@ const (
 	computeInstanceGroupAssetType = "compute.googleapis.com/InstanceGroup"
 	bigqueryDatasetAssetType      = "bigquery.googleapis.com/Dataset"
 	bigqueryTableAssetType        = "bigquery.googleapis.com/Table"
+	computeAddressAssetType       = "compute.googleapis.com/Address"
 )
 
 type AssetRepository interface {
@@ -34,6 +35,7 @@ type AssetRepository interface {
 	SearchAllInstanceGroups() ([]*assetpb.ResourceSearchResult, error)
 	SearchAllDatasets() ([]*assetpb.ResourceSearchResult, error)
 	SearchAllTables() ([]*assetpb.ResourceSearchResult, error)
+	SearchAllAddresses() ([]*assetpb.ResourceSearchResult, error)
 }
 
 type assetRepository struct {
@@ -63,6 +65,7 @@ func (s assetRepository) searchAllResources(ty string) ([]*assetpb.ResourceSearc
 			computeInstanceGroupAssetType,
 			bigqueryDatasetAssetType,
 			bigqueryTableAssetType,
+			computeAddressAssetType,
 		},
 	}
 	var results []*assetpb.ResourceSearchResult
@@ -134,3 +137,7 @@ func (s assetRepository) SearchAllDatasets() ([]*assetpb.ResourceSearchResult, e
 func (s assetRepository) SearchAllTables() ([]*assetpb.ResourceSearchResult, error) {
 	return s.searchAllResources(bigqueryTableAssetType)
 }
+
+func (s assetRepository) SearchAllAddresses() ([]*assetpb.ResourceSearchResult, error) {
+	return s.searchAllResources(computeAddressAssetType)
+}
@@ -24,6 +24,7 @@ import (
 	assetpb "google.golang.org/genproto/googleapis/cloud/asset/v1"
 	"google.golang.org/grpc/codes"
 	"google.golang.org/grpc/status"
+	"google.golang.org/protobuf/types/known/structpb"
 )
 
 func TestGoogleComputeFirewall(t *testing.T) {
@@ -622,3 +623,120 @@ func TestGoogleComputeInstanceGroup(t *testing.T) {
 		})
 	}
 }
+
+func TestGoogleComputeAddress(t *testing.T) {
+
+	cases := []struct {
+		test             string
+		assertExpected   func(t *testing.T, got []*resource.Resource)
+		response         []*assetpb.ResourceSearchResult
+		responseErr      error
+		setupAlerterMock func(alerter *mocks.AlerterInterface)
+		wantErr          error
+	}{
+		{
+			test:     "no compute address",
+			response: []*assetpb.ResourceSearchResult{},
+			assertExpected: func(t *testing.T, got []*resource.Resource) {
+				assert.Len(t, got, 0)
+			},
+		},
+		{
+			test: "multiples compute address",
+			assertExpected: func(t *testing.T, got []*resource.Resource) {
+				assert.Len(t, got, 2)
+				assert.Equal(t, "projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address", got[0].ResourceId())
+				assert.Equal(t, "google_compute_address", got[0].ResourceType())
+
+				assert.Equal(t, "projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address-2", got[1].ResourceId())
+				assert.Equal(t, "google_compute_address", got[1].ResourceType())
+				assert.Equal(t, "1.2.3.4", *got[1].Attributes().GetString("address"))
+			},
+			response: []*assetpb.ResourceSearchResult{
+				{
+					AssetType: "compute.googleapis.com/Address",
+					Name:      "//compute.googleapis.com/projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address",
+				},
+				{
+					AssetType: "compute.googleapis.com/Address",
+					Name:      "//compute.googleapis.com/projects/cloudskiff-dev-elie/regions/us-central1/addresses/my-address-2",
+					AdditionalAttributes: func() *structpb.Struct {
+						str, _ := structpb.NewStruct(map[string]interface{}{
+							"address": "1.2.3.4",
+						})
+						return str
+					}(),
+				},
+			},
+		},
+		{
+			test: "cannot list compute address",
+			assertExpected: func(t *testing.T, got []*resource.Resource) {
+				assert.Len(t, got, 0)
+			},
+			responseErr: status.Error(codes.PermissionDenied, "The caller does not have permission"),
+			setupAlerterMock: func(alerter *mocks.AlerterInterface) {
+				alerter.On(
+					"SendAlert",
+					"google_compute_address",
+					alerts.NewRemoteAccessDeniedAlert(
+						common.RemoteGoogleTerraform,
+						remoteerr.NewResourceListingError(
+							status.Error(codes.PermissionDenied, "The caller does not have permission"),
+							"google_compute_address",
+						),
+						alerts.EnumerationPhase,
+					),
+				).Once()
+			},
+		},
+	}
+
+	providerVersion := "3.78.0"
+	schemaRepository := testresource.InitFakeSchemaRepository("google", providerVersion)
+	googleresource.InitResourcesMetadata(schemaRepository)
+	factory := terraform.NewTerraformResourceFactory(schemaRepository)
+
+	for _, c := range cases {
+		t.Run(c.test, func(tt *testing.T) {
+			scanOptions := ScannerOptions{}
+			providerLibrary := terraform.NewProviderLibrary()
+			remoteLibrary := common.NewRemoteLibrary()
+
+			// Initialize mocks
+			alerter := &mocks.AlerterInterface{}
+			if c.setupAlerterMock != nil {
+				c.setupAlerterMock(alerter)
+			}
+
+			assetClient, err := testgoogle.NewFakeAssetServer(c.response, c.responseErr)
+			if err != nil {
+				tt.Fatal(err)
+			}
+
+			realProvider, err := terraform2.InitTestGoogleProvider(providerLibrary, providerVersion)
+			if err != nil {
+				tt.Fatal(err)
+			}
+
+			repo := repository.NewAssetRepository(assetClient, realProvider.GetConfig(), cache.New(0))
+
+			remoteLibrary.AddEnumerator(google.NewGoogleComputeAddressEnumerator(repo, factory))
+
+			testFilter := &filter.MockFilter{}
+			testFilter.On("IsTypeIgnored", mock.Anything).Return(false)
+
+			s := NewScanner(remoteLibrary, alerter, scanOptions, testFilter)
+			got, err := s.Resources()
+			assert.Equal(tt, err, c.wantErr)
+			if err != nil {
+				return
+			}
+			alerter.AssertExpectations(tt)
+			testFilter.AssertExpectations(tt)
+			if c.assertExpected != nil {
+				c.assertExpected(t, got)
+			}
+		})
+	}
+}
@@ -0,0 +1,14 @@
+package google
+
+import "github.com/cloudskiff/driftctl/pkg/resource"
+
+const GoogleComputeAddressResourceType = "google_compute_address"
+
+func initGoogleComputeAddressMetadata(resourceSchemaRepository resource.SchemaRepositoryInterface) {
+	resourceSchemaRepository.SetHumanReadableAttributesFunc(GoogleComputeAddressResourceType, func(res *resource.Resource) map[string]string {
+		return map[string]string{
+			"Name":    *res.Attributes().GetString("name"),
+			"Address": *res.Attributes().GetString("address"),
+		}
+	})
+}
@@ -0,0 +1,30 @@
+package google_test
+
+import (
+	"testing"
+
+	"github.com/cloudskiff/driftctl/test"
+	"github.com/cloudskiff/driftctl/test/acceptance"
+)
+
+func TestAcc_Google_ComputeAddress(t *testing.T) {
+	acceptance.Run(t, acceptance.AccTestCase{
+		TerraformVersion: "0.15.5",
+		Paths:            []string{"./testdata/acc/google_compute_address"},
+		Args: []string{
+			"scan",
+			"--to", "gcp+tf",
+		},
+		Checks: []acceptance.AccCheck{
+			{
+				Check: func(result *test.ScanResult, stdout string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					result.AssertInfrastructureIsInSync()
+					result.AssertManagedCount(1)
+				},
+			},
+		},
+	})
+}
@@ -12,4 +12,5 @@ func InitResourcesMetadata(resourceSchemaRepository resource.SchemaRepositoryInt
 	initGoogleBigqueryDatasetMetadata(resourceSchemaRepository)
 	initGoogleBigqueryTableMetadata(resourceSchemaRepository)
 	initGoogleProjectIAMMemberMetadata(resourceSchemaRepository)
+	initGoogleComputeAddressMetadata(resourceSchemaRepository)
 }
@@ -0,0 +1,2 @@
+*
+!google_compute_address