add support for azurerm_private_dns_zone

go.mod

@@ -10,6 +10,7 @@ require (
 	github.com/Azure/azure-sdk-for-go/sdk/containerregistry/armcontainerregistry v0.2.0
 	github.com/Azure/azure-sdk-for-go/sdk/network/armnetwork v0.3.0
 	github.com/Azure/azure-sdk-for-go/sdk/postgresql/armpostgresql v0.2.0
+	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns v0.1.0
 	github.com/Azure/azure-sdk-for-go/sdk/resources/armresources v0.3.0
 	github.com/Azure/azure-sdk-for-go/sdk/storage/armstorage v0.2.0
 	github.com/Azure/go-autorest/autorest v0.11.3

go.sum

@@ -49,8 +49,9 @@ dmitri.shuralyov.com/gpu/mtl v0.0.0-20190408044501-666a987793e9/go.mod h1:H6x//7
 github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
 github.com/Azure/azure-sdk-for-go v45.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
 github.com/Azure/azure-sdk-for-go v57.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
-github.com/Azure/azure-sdk-for-go v57.1.0+incompatible h1:TKQ3ieyB0vVKkF6t9dsWbMjq56O1xU3eh3Ec09v6ajM=
 github.com/Azure/azure-sdk-for-go v57.1.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
+github.com/Azure/azure-sdk-for-go v58.0.0+incompatible h1:Cw16jiP4dI+CK761aq44ol4RV5dUiIIXky1+EKpoiVM=
+github.com/Azure/azure-sdk-for-go v58.0.0+incompatible/go.mod h1:9XXNKU+eRnpl9moKnB4QOLf1HestfXbmab5FXxiDBjc=
 github.com/Azure/azure-sdk-for-go/sdk/azcore v0.19.0 h1:lhSJz9RMbJcTgxifR1hUNJnn6CNYtbgEDtQV22/9RBA=
 github.com/Azure/azure-sdk-for-go/sdk/azcore v0.19.0/go.mod h1:h6H6c8enJmmocHUbLiiGY6sx7f9i+X3m1CHdd5c6Rdw=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v0.10.0/go.mod h1:HcM1YX14R7CJcghJGOYCgdezslRSVzqwLf/q+4Y2r/0=
@@ -64,6 +65,8 @@ github.com/Azure/azure-sdk-for-go/sdk/network/armnetwork v0.3.0 h1:3ICM5L/XRaknp
 github.com/Azure/azure-sdk-for-go/sdk/network/armnetwork v0.3.0/go.mod h1:YSO+0IW+22kuLybFl2GAYaTDh1VWxNid83hqY/DkpGQ=
 github.com/Azure/azure-sdk-for-go/sdk/postgresql/armpostgresql v0.2.0 h1:EZ1NQo84rR8CmjynKcKXdTsRa1Th+Lc1HGn91eiSvOg=
 github.com/Azure/azure-sdk-for-go/sdk/postgresql/armpostgresql v0.2.0/go.mod h1:sbAG2tkFoaiR112qwra1mWRtY82eu+5R1fq2/tylwmE=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns v0.1.0 h1:UORx/HjbzVZKVYHxkLPxct99ASG3jGhGotwK0el/Jdk=
+github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns v0.1.0/go.mod h1:J1kqqAcDlSkUsBEubT3lQzq73nVwQdHxcsdnttwu2i0=
 github.com/Azure/azure-sdk-for-go/sdk/resources/armresources v0.3.0 h1:I1cONUC2nKiGU3JXm2jRB4+QIs06lGqkplVpwy4ie9o=
 github.com/Azure/azure-sdk-for-go/sdk/resources/armresources v0.3.0/go.mod h1:LdmyxRi5+2XPnbuv0X9c6ymGle+UkoNvqsBvG+oG53M=
 github.com/Azure/azure-sdk-for-go/sdk/storage/armstorage v0.2.0 h1:LOq4ZG6rMgTAZTyGbYHyxL1EVfZdngpUDRY/KvBToMs=

pkg/iac/terraform/state/terraform_state_reader_test.go

@@ -429,6 +429,7 @@ func TestTerraformStateReader_Azure_Resources(t *testing.T) {
 	}{
 		{name: "network security group", dirName: "azurerm_network_security_group", wantErr: false},
 		{name: "load balancers", dirName: "azurerm_lb", wantErr: false},
+		{name: "private dns zone", dirName: "azurerm_private_dns_zone", wantErr: false},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {

pkg/iac/terraform/state/test/azurerm_private_dns_zone/results.golden.json

@@ -0,0 +1,27 @@
+[
+ {
+  "Id": "/subscriptions/7bfb2c5c-7308-46ed-8ae4-fffa356eb406/resourceGroups/martin-dev/providers/Microsoft.Network/privateDnsZones/thisisatestusingtf.com",
+  "Type": "azurerm_private_dns_zone",
+  "Attrs": {
+   "id": "/subscriptions/7bfb2c5c-7308-46ed-8ae4-fffa356eb406/resourceGroups/martin-dev/providers/Microsoft.Network/privateDnsZones/thisisatestusingtf.com",
+   "max_number_of_record_sets": 25000,
+   "max_number_of_virtual_network_links": 1000,
+   "max_number_of_virtual_network_links_with_registration": 100,
+   "name": "thisisatestusingtf.com",
+   "resource_group_name": "martin-dev",
+   "soa_record": [
+    {
+     "email": "azureprivatedns-host.microsoft.com",
+     "expire_time": 2419200,
+     "fqdn": "thisisatestusingtf.com.",
+     "host_name": "azureprivatedns.net",
+     "minimum_ttl": 10,
+     "refresh_time": 3600,
+     "retry_time": 300,
+     "serial_number": 1,
+     "ttl": 3600
+    }
+   ]
+  }
+ }
+]

pkg/iac/terraform/state/test/azurerm_private_dns_zone/terraform.tfstate

@@ -0,0 +1,50 @@
+{
+  "version": 4,
+  "terraform_version": "0.14.5",
+  "serial": 19,
+  "lineage": "7f22faf7-4655-0f68-3b00-9099a46450a7",
+  "outputs": {},
+  "resources": [
+    {
+      "mode": "managed",
+      "type": "azurerm_private_dns_zone",
+      "name": "examplezone",
+      "provider": "provider[\"registry.terraform.io/hashicorp/azurerm\"]",
+      "instances": [
+        {
+          "schema_version": 0,
+          "attributes": {
+            "id": "/subscriptions/7bfb2c5c-7308-46ed-8ae4-fffa356eb406/resourceGroups/martin-dev/providers/Microsoft.Network/privateDnsZones/thisisatestusingtf.com",
+            "max_number_of_record_sets": 25000,
+            "max_number_of_virtual_network_links": 1000,
+            "max_number_of_virtual_network_links_with_registration": 100,
+            "name": "thisisatestusingtf.com",
+            "number_of_record_sets": 1,
+            "resource_group_name": "martin-dev",
+            "soa_record": [
+              {
+                "email": "azureprivatedns-host.microsoft.com",
+                "expire_time": 2419200,
+                "fqdn": "thisisatestusingtf.com.",
+                "host_name": "azureprivatedns.net",
+                "minimum_ttl": 10,
+                "refresh_time": 3600,
+                "retry_time": 300,
+                "serial_number": 1,
+                "tags": {},
+                "ttl": 3600
+              }
+            ],
+            "tags": null,
+            "timeouts": null
+          },
+          "sensitive_attributes": [],
+          "private": "eyJlMmJmYjczMC1lY2FhLTExZTYtOGY4OC0zNDM2M2JjN2M0YzAiOnsiY3JlYXRlIjoxODAwMDAwMDAwMDAwLCJkZWxldGUiOjE4MDAwMDAwMDAwMDAsInJlYWQiOjMwMDAwMDAwMDAwMCwidXBkYXRlIjoxODAwMDAwMDAwMDAwfX0=",
+          "dependencies": [
+            "data.azurerm_resource_group.martin"
+          ]
+        }
+      ]
+    }
+  ]
+}

pkg/remote/azurerm/azurerm_privatedns_zone_enumerator.go

@@ -0,0 +1,49 @@
+package azurerm
+
+import (
+	"github.com/cloudskiff/driftctl/pkg/remote/azurerm/repository"
+	remoteerror "github.com/cloudskiff/driftctl/pkg/remote/error"
+	"github.com/cloudskiff/driftctl/pkg/resource"
+	"github.com/cloudskiff/driftctl/pkg/resource/azurerm"
+)
+
+type AzurermPrivateDNSZoneEnumerator struct {
+	repository repository.PrivateDNSRepository
+	factory    resource.ResourceFactory
+}
+
+func NewAzurermPrivateDNSZoneEnumerator(repo repository.PrivateDNSRepository, factory resource.ResourceFactory) *AzurermPrivateDNSZoneEnumerator {
+	return &AzurermPrivateDNSZoneEnumerator{
+		repository: repo,
+		factory:    factory,
+	}
+}
+
+func (e *AzurermPrivateDNSZoneEnumerator) SupportedType() resource.ResourceType {
+	return azurerm.AzurePrivateDNSZoneResourceType
+}
+
+func (e *AzurermPrivateDNSZoneEnumerator) Enumerate() ([]*resource.Resource, error) {
+
+	zones, err := e.repository.ListAllPrivateZones()
+	if err != nil {
+		return nil, remoteerror.NewResourceListingError(err, string(e.SupportedType()))
+	}
+
+	results := make([]*resource.Resource, 0)
+
+	for _, zone := range zones {
+
+		results = append(
+			results,
+			e.factory.CreateAbstractResource(
+				string(e.SupportedType()),
+				*zone.ID,
+				map[string]interface{}{},
+			),
+		)
+
+	}
+
+	return results, err
+}

pkg/remote/azurerm/init.go

@@ -46,6 +46,7 @@ func Init(
 	resourcesRepo := repository.NewResourcesRepository(con, providerConfig, c)
 	containerRegistryRepo := repository.NewContainerRegistryRepository(con, providerConfig, c)
 	postgresqlRepo := repository.NewPostgresqlRepository(con, providerConfig, c)
+	privateDNSRepo := repository.NewPrivateDNSRepository(con, providerConfig, c)
 
 	providerLibrary.AddProvider(terraform.AZURE, provider)
 	deserializer := resource.NewDeserializer(factory)
@@ -65,6 +66,8 @@ func Init(
 	remoteLibrary.AddEnumerator(NewAzurermNetworkSecurityGroupEnumerator(networkRepo, factory))
 	remoteLibrary.AddDetailsFetcher(azurerm.AzureNetworkSecurityGroupResourceType, common.NewGenericDetailsFetcher(azurerm.AzureNetworkSecurityGroupResourceType, provider, deserializer))
 	remoteLibrary.AddEnumerator(NewAzurermLoadBalancerEnumerator(networkRepo, factory))
+	remoteLibrary.AddEnumerator(NewAzurermPrivateDNSZoneEnumerator(privateDNSRepo, factory))
+	remoteLibrary.AddDetailsFetcher(azurerm.AzurePrivateDNSZoneResourceType, common.NewGenericDetailsFetcher(azurerm.AzurePrivateDNSZoneResourceType, provider, deserializer))
 
 	err = resourceSchemaRepository.Init(terraform.AZURE, provider.Version(), provider.Schema())
 	if err != nil {

pkg/remote/azurerm/repository/mock_PrivateDNSRepository.go

@@ -0,0 +1,36 @@
+// Code generated by mockery v0.0.0-dev. DO NOT EDIT.
+
+package repository
+
+import (
+	armprivatedns "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// MockPrivateDNSRepository is an autogenerated mock type for the PrivateDNSRepository type
+type MockPrivateDNSRepository struct {
+	mock.Mock
+}
+
+// ListAllPrivateZones provides a mock function with given fields:
+func (_m *MockPrivateDNSRepository) ListAllPrivateZones() ([]*armprivatedns.PrivateZone, error) {
+	ret := _m.Called()
+
+	var r0 []*armprivatedns.PrivateZone
+	if rf, ok := ret.Get(0).(func() []*armprivatedns.PrivateZone); ok {
+		r0 = rf()
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).([]*armprivatedns.PrivateZone)
+		}
+	}
+
+	var r1 error
+	if rf, ok := ret.Get(1).(func() error); ok {
+		r1 = rf()
+	} else {
+		r1 = ret.Error(1)
+	}
+
+	return r0, r1
+}

pkg/remote/azurerm/repository/mock_privateDNSZoneListPager.go

@@ -0,0 +1,58 @@
+// Code generated by mockery v0.0.0-dev. DO NOT EDIT.
+
+package repository
+
+import (
+	context "context"
+
+	armprivatedns "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns"
+
+	mock "github.com/stretchr/testify/mock"
+)
+
+// mockPrivateDNSZoneListPager is an autogenerated mock type for the privateDNSZoneListPager type
+type mockPrivateDNSZoneListPager struct {
+	mock.Mock
+}
+
+// Err provides a mock function with given fields:
+func (_m *mockPrivateDNSZoneListPager) Err() error {
+	ret := _m.Called()
+
+	var r0 error
+	if rf, ok := ret.Get(0).(func() error); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Error(0)
+	}
+
+	return r0
+}
+
+// NextPage provides a mock function with given fields: ctx
+func (_m *mockPrivateDNSZoneListPager) NextPage(ctx context.Context) bool {
+	ret := _m.Called(ctx)
+
+	var r0 bool
+	if rf, ok := ret.Get(0).(func(context.Context) bool); ok {
+		r0 = rf(ctx)
+	} else {
+		r0 = ret.Get(0).(bool)
+	}
+
+	return r0
+}
+
+// PageResponse provides a mock function with given fields:
+func (_m *mockPrivateDNSZoneListPager) PageResponse() armprivatedns.PrivateZonesListResponse {
+	ret := _m.Called()
+
+	var r0 armprivatedns.PrivateZonesListResponse
+	if rf, ok := ret.Get(0).(func() armprivatedns.PrivateZonesListResponse); ok {
+		r0 = rf()
+	} else {
+		r0 = ret.Get(0).(armprivatedns.PrivateZonesListResponse)
+	}
+
+	return r0
+}

pkg/remote/azurerm/repository/mock_privateZonesClient.go

@@ -0,0 +1,29 @@
+// Code generated by mockery v0.0.0-dev. DO NOT EDIT.
+
+package repository
+
+import (
+	armprivatedns "github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns"
+	mock "github.com/stretchr/testify/mock"
+)
+
+// mockPrivateZonesClient is an autogenerated mock type for the privateZonesClient type
+type mockPrivateZonesClient struct {
+	mock.Mock
+}
+
+// List provides a mock function with given fields: options
+func (_m *mockPrivateZonesClient) List(options *armprivatedns.PrivateZonesListOptions) privateDNSZoneListPager {
+	ret := _m.Called(options)
+
+	var r0 privateDNSZoneListPager
+	if rf, ok := ret.Get(0).(func(*armprivatedns.PrivateZonesListOptions) privateDNSZoneListPager); ok {
+		r0 = rf(options)
+	} else {
+		if ret.Get(0) != nil {
+			r0 = ret.Get(0).(privateDNSZoneListPager)
+		}
+	}
+
+	return r0
+}

pkg/remote/azurerm/repository/privatedns.go

@@ -0,0 +1,68 @@
+package repository
+
+import (
+	"context"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/arm"
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns"
+	"github.com/cloudskiff/driftctl/pkg/remote/azurerm/common"
+	"github.com/cloudskiff/driftctl/pkg/remote/cache"
+)
+
+type PrivateDNSRepository interface {
+	ListAllPrivateZones() ([]*armprivatedns.PrivateZone, error)
+}
+
+type privateDNSZoneListPager interface {
+	pager
+	PageResponse() armprivatedns.PrivateZonesListResponse
+}
+
+type privateZonesClient interface {
+	List(options *armprivatedns.PrivateZonesListOptions) privateDNSZoneListPager
+}
+
+type privateZonesClientImpl struct {
+	client *armprivatedns.PrivateZonesClient
+}
+
+func (c *privateZonesClientImpl) List(options *armprivatedns.PrivateZonesListOptions) privateDNSZoneListPager {
+	return c.client.List(options)
+}
+
+type privateDNSRepository struct {
+	zoneClient privateZonesClient
+	cache      cache.Cache
+}
+
+func NewPrivateDNSRepository(con *arm.Connection, config common.AzureProviderConfig, cache cache.Cache) *privateDNSRepository {
+	return &privateDNSRepository{
+		&privateZonesClientImpl{armprivatedns.NewPrivateZonesClient(con, config.SubscriptionID)},
+		cache,
+	}
+}
+
+func (s *privateDNSRepository) ListAllPrivateZones() ([]*armprivatedns.PrivateZone, error) {
+	cacheKey := "privateDNSListAllPrivateZones"
+	if v := s.cache.Get(cacheKey); v != nil {
+		return v.([]*armprivatedns.PrivateZone), nil
+	}
+
+	pager := s.zoneClient.List(nil)
+	results := make([]*armprivatedns.PrivateZone, 0)
+	for pager.NextPage(context.Background()) {
+		resp := pager.PageResponse()
+		if err := pager.Err(); err != nil {
+			return nil, err
+		}
+		results = append(results, resp.Value...)
+	}
+
+	if err := pager.Err(); err != nil {
+		return nil, err
+	}
+
+	s.cache.Put(cacheKey, results)
+
+	return results, nil
+}

pkg/remote/azurerm/repository/privatedns_test.go

@@ -0,0 +1,180 @@
+package repository
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns"
+	"github.com/cloudskiff/driftctl/pkg/remote/cache"
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func Test_ListAllPrivateZones_MultiplesResults(t *testing.T) {
+
+	expected := []*armprivatedns.PrivateZone{
+		{
+			TrackedResource: armprivatedns.TrackedResource{
+				Resource: armprivatedns.Resource{
+					ID: func(s string) *string { return &s }("zone1"),
+				},
+			},
+		},
+		{
+			TrackedResource: armprivatedns.TrackedResource{
+				Resource: armprivatedns.Resource{
+					ID: func(s string) *string { return &s }("zone2"),
+				},
+			},
+		},
+		{
+			TrackedResource: armprivatedns.TrackedResource{
+				Resource: armprivatedns.Resource{
+					ID: func(s string) *string { return &s }("zone3"),
+				},
+			},
+		},
+		{
+			TrackedResource: armprivatedns.TrackedResource{
+				Resource: armprivatedns.Resource{
+					ID: func(s string) *string { return &s }("zone4"),
+				},
+			},
+		},
+	}
+
+	fakeClient := &mockPrivateZonesClient{}
+
+	mockPager := &mockPrivateDNSZoneListPager{}
+	mockPager.On("Err").Return(nil).Times(3)
+	mockPager.On("NextPage", mock.Anything).Return(true).Times(2)
+	mockPager.On("NextPage", mock.Anything).Return(false).Times(1)
+	mockPager.On("PageResponse").Return(armprivatedns.PrivateZonesListResponse{
+		PrivateZonesListResult: armprivatedns.PrivateZonesListResult{
+			PrivateZoneListResult: armprivatedns.PrivateZoneListResult{
+				Value: []*armprivatedns.PrivateZone{
+					{
+						TrackedResource: armprivatedns.TrackedResource{
+							Resource: armprivatedns.Resource{
+								ID: func(s string) *string { return &s }("zone1"),
+							},
+						},
+					},
+					{
+						TrackedResource: armprivatedns.TrackedResource{
+							Resource: armprivatedns.Resource{
+								ID: func(s string) *string { return &s }("zone2"),
+							},
+						},
+					},
+				},
+			},
+		},
+	}).Times(1)
+	mockPager.On("PageResponse").Return(armprivatedns.PrivateZonesListResponse{
+		PrivateZonesListResult: armprivatedns.PrivateZonesListResult{
+			PrivateZoneListResult: armprivatedns.PrivateZoneListResult{
+				Value: []*armprivatedns.PrivateZone{
+					{
+						TrackedResource: armprivatedns.TrackedResource{
+							Resource: armprivatedns.Resource{
+								ID: func(s string) *string { return &s }("zone3"),
+							},
+						},
+					},
+					{
+						TrackedResource: armprivatedns.TrackedResource{
+							Resource: armprivatedns.Resource{
+								ID: func(s string) *string { return &s }("zone4"),
+							},
+						},
+					},
+				},
+			},
+		},
+	}).Times(1)
+
+	fakeClient.On("List", mock.Anything).Return(mockPager)
+
+	c := &cache.MockCache{}
+	c.On("Get", "privateDNSListAllPrivateZones").Return(nil).Times(1)
+	c.On("Put", "privateDNSListAllPrivateZones", expected).Return(true).Times(1)
+	s := &privateDNSRepository{
+		zoneClient: fakeClient,
+		cache:      c,
+	}
+	got, err := s.ListAllPrivateZones()
+	if err != nil {
+		t.Errorf("ListAllPrivateZones() error = %v", err)
+		return
+	}
+
+	mockPager.AssertExpectations(t)
+	fakeClient.AssertExpectations(t)
+	c.AssertExpectations(t)
+
+	if !reflect.DeepEqual(got, expected) {
+		t.Errorf("ListAllPrivateZones() got = %v, want %v", got, expected)
+	}
+}
+
+func Test_ListAllPrivateZones_MultiplesResults_WithCache(t *testing.T) {
+
+	expected := []*armprivatedns.PrivateZone{
+		{
+			TrackedResource: armprivatedns.TrackedResource{
+				Resource: armprivatedns.Resource{
+					ID: func(s string) *string { return &s }("zone1"),
+				},
+			},
+		},
+	}
+
+	fakeClient := &mockPrivateZonesClient{}
+
+	c := &cache.MockCache{}
+	c.On("Get", "privateDNSListAllPrivateZones").Return(expected).Times(1)
+	s := &privateDNSRepository{
+		zoneClient: fakeClient,
+		cache:      c,
+	}
+	got, err := s.ListAllPrivateZones()
+	if err != nil {
+		t.Errorf("ListAllPrivateZones() error = %v", err)
+		return
+	}
+
+	fakeClient.AssertExpectations(t)
+	c.AssertExpectations(t)
+
+	if !reflect.DeepEqual(got, expected) {
+		t.Errorf("ListAllPrivateZones() got = %v, want %v", got, expected)
+	}
+}
+
+func Test_ListAllPrivateZones_Error(t *testing.T) {
+
+	fakeClient := &mockPrivateZonesClient{}
+
+	expectedErr := errors.New("unexpected error")
+
+	mockPager := &mockPrivateDNSZoneListPager{}
+	mockPager.On("Err").Return(expectedErr).Times(1)
+	mockPager.On("NextPage", mock.Anything).Return(true).Times(1)
+	mockPager.On("PageResponse").Return(armprivatedns.PrivateZonesListResponse{}).Times(1)
+
+	fakeClient.On("List", mock.Anything).Return(mockPager)
+
+	s := &privateDNSRepository{
+		zoneClient: fakeClient,
+		cache:      cache.New(0),
+	}
+	got, err := s.ListAllPrivateZones()
+
+	mockPager.AssertExpectations(t)
+	fakeClient.AssertExpectations(t)
+
+	assert.Equal(t, expectedErr, err)
+	assert.Nil(t, got)
+}

pkg/remote/azurerm_privatedns_scanner_test.go

@@ -0,0 +1,116 @@
+package remote
+
+import (
+	"testing"
+
+	"github.com/Azure/azure-sdk-for-go/sdk/azcore/to"
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/privatedns/armprivatedns"
+	"github.com/cloudskiff/driftctl/mocks"
+	"github.com/cloudskiff/driftctl/pkg/filter"
+	"github.com/cloudskiff/driftctl/pkg/remote/azurerm"
+	"github.com/cloudskiff/driftctl/pkg/remote/azurerm/repository"
+	"github.com/cloudskiff/driftctl/pkg/remote/common"
+	error2 "github.com/cloudskiff/driftctl/pkg/remote/error"
+	"github.com/cloudskiff/driftctl/pkg/resource"
+	resourceazure "github.com/cloudskiff/driftctl/pkg/resource/azurerm"
+	"github.com/cloudskiff/driftctl/pkg/terraform"
+	testresource "github.com/cloudskiff/driftctl/test/resource"
+	"github.com/pkg/errors"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+func TestAzurermPrivateDNSZone(t *testing.T) {
+
+	dummyError := errors.New("this is an error")
+
+	tests := []struct {
+		test           string
+		mocks          func(*repository.MockPrivateDNSRepository, *mocks.AlerterInterface)
+		assertExpected func(t *testing.T, got []*resource.Resource)
+		wantErr        error
+	}{
+		{
+			test: "no PrivateZone",
+			mocks: func(repository *repository.MockPrivateDNSRepository, alerter *mocks.AlerterInterface) {
+				repository.On("ListAllPrivateZones").Return([]*armprivatedns.PrivateZone{}, nil)
+			},
+			assertExpected: func(t *testing.T, got []*resource.Resource) {
+				assert.Len(t, got, 0)
+			},
+		},
+		{
+			test: "error listing PrivateZone",
+			mocks: func(repository *repository.MockPrivateDNSRepository, alerter *mocks.AlerterInterface) {
+				repository.On("ListAllPrivateZones").Return(nil, dummyError)
+			},
+			wantErr: error2.NewResourceListingError(dummyError, resourceazure.AzurePrivateDNSZoneResourceType),
+		},
+		{
+			test: "multiple PrivateZone",
+			mocks: func(repository *repository.MockPrivateDNSRepository, alerter *mocks.AlerterInterface) {
+				repository.On("ListAllPrivateZones").Return([]*armprivatedns.PrivateZone{
+					{
+						TrackedResource: armprivatedns.TrackedResource{
+							Resource: armprivatedns.Resource{
+								ID: to.StringPtr("driftctlzone1"),
+							},
+						},
+					},
+					{
+						TrackedResource: armprivatedns.TrackedResource{
+							Resource: armprivatedns.Resource{
+								ID: to.StringPtr("driftctlzone2"),
+							},
+						},
+					},
+				}, nil)
+			},
+			assertExpected: func(t *testing.T, got []*resource.Resource) {
+				assert.Len(t, got, 2)
+
+				assert.Equal(t, got[0].ResourceId(), "driftctlzone1")
+				assert.Equal(t, got[0].ResourceType(), resourceazure.AzurePrivateDNSZoneResourceType)
+
+				assert.Equal(t, got[1].ResourceId(), "driftctlzone2")
+				assert.Equal(t, got[1].ResourceType(), resourceazure.AzurePrivateDNSZoneResourceType)
+			},
+		},
+	}
+
+	providerVersion := "2.71.0"
+	schemaRepository := testresource.InitFakeSchemaRepository("azurerm", providerVersion)
+	resourceazure.InitResourcesMetadata(schemaRepository)
+	factory := terraform.NewTerraformResourceFactory(schemaRepository)
+
+	for _, c := range tests {
+		t.Run(c.test, func(tt *testing.T) {
+
+			scanOptions := ScannerOptions{Deep: true}
+			remoteLibrary := common.NewRemoteLibrary()
+
+			// Initialize mocks
+			alerter := &mocks.AlerterInterface{}
+			fakeRepo := &repository.MockPrivateDNSRepository{}
+			c.mocks(fakeRepo, alerter)
+
+			var repo repository.PrivateDNSRepository = fakeRepo
+
+			remoteLibrary.AddEnumerator(azurerm.NewAzurermPrivateDNSZoneEnumerator(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, c.wantErr, err)
+			if err != nil {
+				return
+			}
+
+			c.assertExpected(tt, got)
+			alerter.AssertExpectations(tt)
+			fakeRepo.AssertExpectations(tt)
+		})
+	}
+}

pkg/resource/azurerm/azurerm_private_dns_zone.go

@@ -0,0 +1,15 @@
+package azurerm
+
+import (
+	"github.com/cloudskiff/driftctl/pkg/resource"
+)
+
+const AzurePrivateDNSZoneResourceType = "azurerm_private_dns_zone"
+
+func initAzurePrivateDNSZoneMetaData(resourceSchemaRepository resource.SchemaRepositoryInterface) {
+	resourceSchemaRepository.SetNormalizeFunc(AzurePrivateDNSZoneResourceType, func(res *resource.Resource) {
+		res.Attributes().SafeDelete([]string{"number_of_record_sets"})
+		res.Attributes().SafeDelete([]string{"timeouts"})
+	})
+	resourceSchemaRepository.SetFlags(AzurePrivateDNSZoneResourceType, resource.FlagDeepMode)
+}

pkg/resource/azurerm/azurerm_private_dns_zone_test.go

@@ -0,0 +1,30 @@
+package azurerm_test
+
+import (
+	"testing"
+
+	"github.com/cloudskiff/driftctl/test"
+	"github.com/cloudskiff/driftctl/test/acceptance"
+)
+
+func TestAcc_Azure_PrivateDNSZone(t *testing.T) {
+	acceptance.Run(t, acceptance.AccTestCase{
+		TerraformVersion: "0.15.5",
+		Paths:            []string{"./testdata/acc/azurerm_private_dns_zone"},
+		Args: []string{
+			"scan",
+			"--to", "azure+tf", "--deep",
+		},
+		Checks: []acceptance.AccCheck{
+			{
+				Check: func(result *test.ScanResult, stdout string, err error) {
+					if err != nil {
+						t.Fatal(err)
+					}
+					result.AssertInfrastructureIsInSync()
+					result.AssertManagedCount(1)
+				},
+			},
+		},
+	})
+}

pkg/resource/azurerm/metadata.go

@@ -14,4 +14,5 @@ func InitResourcesMetadata(resourceSchemaRepository resource.SchemaRepositoryInt
 	initAzurePostgresqlDatabaseMetadata(resourceSchemaRepository)
 	initAzureNetworkSecurityGroupMetadata(resourceSchemaRepository)
 	initAzureLoadBalancerMetadata(resourceSchemaRepository)
+	initAzurePrivateDNSZoneMetaData(resourceSchemaRepository)
 }

pkg/resource/azurerm/metadata_test.go

@@ -25,6 +25,7 @@ func TestAzureMetadata_Flags(t *testing.T) {
 		AzureVirtualNetworkResourceType:       {},
 		AzureNetworkSecurityGroupResourceType: {resource.FlagDeepMode},
 		AzureLoadBalancerResourceType:         {},
+		AzurePrivateDNSZoneResourceType:       {resource.FlagDeepMode},
 	}
 
 	schemaRepository := testresource.InitFakeSchemaRepository(tf.AZURE, "2.71.0")

pkg/resource/azurerm/testdata/acc/azurerm_private_dns_zone/.driftignore

@@ -0,0 +1,2 @@
+*
+!azurerm_private_dns_zone

pkg/resource/azurerm/testdata/acc/azurerm_private_dns_zone/terraform.tf

@@ -0,0 +1,21 @@
+terraform {
+    required_providers {
+        azurerm = {
+            source  = "hashicorp/azurerm"
+            version = "~> 2.71.0"
+        }
+    }
+}
+
+provider "azurerm" {
+    features {}
+}
+
+data "azurerm_resource_group" "example" {
+    name = "driftctl-qa-1"
+}
+
+resource "azurerm_private_dns_zone" "examplezone" {
+    name                = "thisisatestusingtf.com"
+    resource_group_name = data.azurerm_resource_group.example.name
+}

pkg/resource/resource_types.go

@@ -182,6 +182,7 @@ var supportedTypes = map[string]ResourceTypeMeta{
 	"azurerm_public_ip":              {},
 	"azurerm_network_security_group": {},
 	"azurerm_lb":                     {},
+	"azurerm_private_dns_zone":       {},
 }
 
 func IsResourceTypeSupported(ty string) bool {