Repository: cycloidio/terracost
Pull request #115 (2023-10-09 17:52:31)

aws support for aws_fsx_lustre_file_system, aws_fsx_ontap_file_system, aws_fsx_openzfs_file_system, aws_fsx_windows_file_system
`aws_fsx_lustre_file_system`, `aws_fsx_ontap_file_system`, `aws_fsx_openzfs_file_system`, `aws_fsx_windows_file_system`


Patch:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5158342..313ea71 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 
 ### Added
 
+- AWS support for `aws_fsx_lustre_file_system`, `aws_fsx_ontap_file_system`, `aws_fsx_openzfs_file_system`, `aws_fsx_windows_file_system`
+  ([Pull #115](https://github.com/cycloidio/terracost/pull/115))
 - AWS support for `aws_nat_gateway`
   ([Pull #110](https://github.com/cycloidio/terracost/pull/110))
 - AWS support for `aws_eks_cluster`, `aws_eks_node_group`, `aws_efs_file_system`
diff --git a/aws/field/field.go b/aws/field/field.go
index 04bc689..d44429c 100644
--- a/aws/field/field.go
+++ b/aws/field/field.go
@@ -36,6 +36,12 @@ const (
 	DeploymentOption // Deployment Option
 	LicenseModel     // License Model
 
+	// FSx fields
+	FileSystemType     // File system type
+	StorageType        // Storage type
+	ThroughputCapacity // Throughput capacity
+	Deployment_option  // Deployment option
+
 	///// Price Attributes /////
 	Currency      // Currency
 	PricePerUnit  // PricePerUnit
diff --git a/aws/field/field_gen.go b/aws/field/field_gen.go
index 7cdaf92..f1cbe90 100644
--- a/aws/field/field_gen.go
+++ b/aws/field/field_gen.go
@@ -7,11 +7,11 @@ import (
 	"strings"
 )
 
-const _FieldName = "SKUCapacityStatusGroupInstance TypeLocationOperating SystemPre Installed S/WProduct FamilyserviceCodeTenancyusageTypeVolume API NameVolume TypeStorage ClassAccess TypeThroughput ClassCache EngineDatabase EngineDatabase EditionDeployment OptionLicense ModelCurrencyPricePerUnitStartingRangeTermTypeUnit"
+const _FieldName = "SKUCapacityStatusGroupInstance TypeLocationOperating SystemPre Installed S/WProduct FamilyserviceCodeTenancyusageTypeVolume API NameVolume TypeStorage ClassAccess TypeThroughput ClassCache EngineDatabase EngineDatabase EditionDeployment OptionLicense ModelFile system typeStorage typeThroughput capacityDeployment optionCurrencyPricePerUnitStartingRangeTermTypeUnit"
 
-var _FieldIndex = [...]uint16{0, 3, 17, 22, 35, 43, 59, 76, 90, 101, 108, 117, 132, 143, 156, 167, 183, 195, 210, 226, 243, 256, 264, 276, 289, 297, 301}
+var _FieldIndex = [...]uint16{0, 3, 17, 22, 35, 43, 59, 76, 90, 101, 108, 117, 132, 143, 156, 167, 183, 195, 210, 226, 243, 256, 272, 284, 303, 320, 328, 340, 353, 361, 365}
 
-const _FieldLowerName = "skucapacitystatusgroupinstance typelocationoperating systempre installed s/wproduct familyservicecodetenancyusagetypevolume api namevolume typestorage classaccess typethroughput classcache enginedatabase enginedatabase editiondeployment optionlicense modelcurrencypriceperunitstartingrangetermtypeunit"
+const _FieldLowerName = "skucapacitystatusgroupinstance typelocationoperating systempre installed s/wproduct familyservicecodetenancyusagetypevolume api namevolume typestorage classaccess typethroughput classcache enginedatabase enginedatabase editiondeployment optionlicense modelfile system typestorage typethroughput capacitydeployment optioncurrencypriceperunitstartingrangetermtypeunit"
 
 func (i Field) String() string {
 	if i >= Field(len(_FieldIndex)-1) {
@@ -45,14 +45,18 @@ func _FieldNoOp() {
 	_ = x[DatabaseEdition-(18)]
 	_ = x[DeploymentOption-(19)]
 	_ = x[LicenseModel-(20)]
-	_ = x[Currency-(21)]
-	_ = x[PricePerUnit-(22)]
-	_ = x[StartingRange-(23)]
-	_ = x[TermType-(24)]
-	_ = x[Unit-(25)]
+	_ = x[FileSystemType-(21)]
+	_ = x[StorageType-(22)]
+	_ = x[ThroughputCapacity-(23)]
+	_ = x[Deployment_option-(24)]
+	_ = x[Currency-(25)]
+	_ = x[PricePerUnit-(26)]
+	_ = x[StartingRange-(27)]
+	_ = x[TermType-(28)]
+	_ = x[Unit-(29)]
 }
 
-var _FieldValues = []Field{SKU, CapacityStatus, Group, InstanceType, Location, OperatingSystem, PreInstalledSW, ProductFamily, ServiceCode, Tenancy, UsageType, VolumeAPIName, VolumeType, StorageClass, AccessType, ThroughputClass, CacheEngine, DatabaseEngine, DatabaseEdition, DeploymentOption, LicenseModel, Currency, PricePerUnit, StartingRange, TermType, Unit}
+var _FieldValues = []Field{SKU, CapacityStatus, Group, InstanceType, Location, OperatingSystem, PreInstalledSW, ProductFamily, ServiceCode, Tenancy, UsageType, VolumeAPIName, VolumeType, StorageClass, AccessType, ThroughputClass, CacheEngine, DatabaseEngine, DatabaseEdition, DeploymentOption, LicenseModel, FileSystemType, StorageType, ThroughputCapacity, Deployment_option, Currency, PricePerUnit, StartingRange, TermType, Unit}
 
 var _FieldNameToValueMap = map[string]Field{
 	_FieldName[0:3]:          SKU,
@@ -97,16 +101,24 @@ var _FieldNameToValueMap = map[string]Field{
 	_FieldLowerName[226:243]: DeploymentOption,
 	_FieldName[243:256]:      LicenseModel,
 	_FieldLowerName[243:256]: LicenseModel,
-	_FieldName[256:264]:      Currency,
-	_FieldLowerName[256:264]: Currency,
-	_FieldName[264:276]:      PricePerUnit,
-	_FieldLowerName[264:276]: PricePerUnit,
-	_FieldName[276:289]:      StartingRange,
-	_FieldLowerName[276:289]: StartingRange,
-	_FieldName[289:297]:      TermType,
-	_FieldLowerName[289:297]: TermType,
-	_FieldName[297:301]:      Unit,
-	_FieldLowerName[297:301]: Unit,
+	_FieldName[256:272]:      FileSystemType,
+	_FieldLowerName[256:272]: FileSystemType,
+	_FieldName[272:284]:      StorageType,
+	_FieldLowerName[272:284]: StorageType,
+	_FieldName[284:303]:      ThroughputCapacity,
+	_FieldLowerName[284:303]: ThroughputCapacity,
+	_FieldName[303:320]:      Deployment_option,
+	_FieldLowerName[303:320]: Deployment_option,
+	_FieldName[320:328]:      Currency,
+	_FieldLowerName[320:328]: Currency,
+	_FieldName[328:340]:      PricePerUnit,
+	_FieldLowerName[328:340]: PricePerUnit,
+	_FieldName[340:353]:      StartingRange,
+	_FieldLowerName[340:353]: StartingRange,
+	_FieldName[353:361]:      TermType,
+	_FieldLowerName[353:361]: TermType,
+	_FieldName[361:365]:      Unit,
+	_FieldLowerName[361:365]: Unit,
 }
 
 var _FieldNames = []string{
@@ -131,11 +143,15 @@ var _FieldNames = []string{
 	_FieldName[210:226],
 	_FieldName[226:243],
 	_FieldName[243:256],
-	_FieldName[256:264],
-	_FieldName[264:276],
-	_FieldName[276:289],
-	_FieldName[289:297],
-	_FieldName[297:301],
+	_FieldName[256:272],
+	_FieldName[272:284],
+	_FieldName[284:303],
+	_FieldName[303:320],
+	_FieldName[320:328],
+	_FieldName[328:340],
+	_FieldName[340:353],
+	_FieldName[353:361],
+	_FieldName[361:365],
 }
 
 // FieldString retrieves an enum value from the enum constants string name.
@@ -144,8 +160,8 @@ func FieldString(s string) (Field, error) {
 	if val, ok := _FieldNameToValueMap[s]; ok {
 		return val, nil
 	}
-	s = strings.ToLower(s)
-	if val, ok := _FieldNameToValueMap[s]; ok {
+
+	if val, ok := _FieldNameToValueMap[strings.ToLower(s)]; ok {
 		return val, nil
 	}
 	return 0, fmt.Errorf("%s does not belong to Field values", s)
diff --git a/aws/filter.go b/aws/filter.go
index 0b34218..aa19057 100644
--- a/aws/filter.go
+++ b/aws/filter.go
@@ -30,6 +30,8 @@ func MinimalFilter(pp *price.WithProduct) bool {
 		return true // is minimal already
 	case "AmazonEFS":
 		return true // is minimal already
+	case "AmazonFSx":
+		return true
 	default:
 		return false
 	}
diff --git a/aws/ingester.go b/aws/ingester.go
index 959931f..3640f46 100644
--- a/aws/ingester.go
+++ b/aws/ingester.go
@@ -214,6 +214,12 @@ var columnProductToIngest = map[field.Field]string{
 	field.DatabaseEdition:  "DatabaseEdition",
 	field.DeploymentOption: "DeploymentOption",
 	field.LicenseModel:     "LicenseModel",
+
+	// FSx attributes
+	field.FileSystemType:     "FileSystemType",
+	field.StorageType:        "StorageType",
+	field.ThroughputCapacity: "ThroughputCapacity",
+	field.Deployment_option:  "Deployment_option",
 }
 
 // columnPriceToIngest is a mapping from column title to the price.Price attribute name under which the value will
diff --git a/aws/services.go b/aws/services.go
index 3a95a7f..c016a35 100644
--- a/aws/services.go
+++ b/aws/services.go
@@ -5,6 +5,7 @@ var supportedServices = map[string]struct{}{
 	"AmazonEC2":         {},
 	"AmazonEFS":         {},
 	"AmazonEKS":         {},
+	"AmazonFSx":         {},
 	"AmazonRDS":         {},
 	"AmazonElastiCache": {},
 	"AmazonCloudWatch":  {},
diff --git a/aws/terraform/fsx_lustre_file_system.go b/aws/terraform/fsx_lustre_file_system.go
new file mode 100644
index 0000000..f980e67
--- /dev/null
+++ b/aws/terraform/fsx_lustre_file_system.go
@@ -0,0 +1,95 @@
+package terraform
+
+import (
+	"github.com/mitchellh/mapstructure"
+	"github.com/shopspring/decimal"
+
+	"github.com/cycloidio/terracost/terraform"
+)
+
+// fsxLustreFileSystemValues represents the structure of Terraform values for aws_efs_file_system resource.
+type fsxLustreFileSystemValues struct {
+	StorageCapacity              float64  `mapstructure:"storage_capacity"`
+	StorageType                  string   `mapstructure:"storage_type"`
+	DeploymentType               string   `mapstructure:"deployment_type"`
+	PerUnitStorageThroughput     float64  `mapstructure:"per_unit_storage_throughput"`
+	SubnetIds                    []string `mapstructure:"subnet_ids"`
+	AutomaticBackupRetentionDays float64  `mapstructure:"automatic_backup_retention_days"`
+
+	Usage struct {
+		BackupStorageGB float64 `mapstructure:"backup_storage_gb"`
+	} `mapstructure:"tc_usage"`
+}
+
+// decodeFSxLustreFileSystemValues decodes and returns fsxLustreFileSystemValues from a Terraform values map.
+func decodeFSxLustreFileSystemValues(tfVals map[string]interface{}) (fsxLustreFileSystemValues, error) {
+	var v fsxLustreFileSystemValues
+	config := &mapstructure.DecoderConfig{
+		WeaklyTypedInput: true,
+		Result:           &v,
+	}
+
+	decoder, err := mapstructure.NewDecoder(config)
+	if err != nil {
+		return v, err
+	}
+
+	if err := decoder.Decode(tfVals); err != nil {
+		return v, err
+	}
+	return v, nil
+}
+
+// newFSxLustreFileSystem creates a new FSxLustreFileSystem from fsxLustreFileSystemValues.
+func (p *Provider) newFSxLustreFileSystem(rss map[string]terraform.Resource, vals fsxLustreFileSystemValues) *FSxFileSystem {
+	v := &FSxFileSystem{
+		provider:           p,
+		region:             p.region,
+		storageType:        "SSD",
+		storageCapacity:    decimal.NewFromFloat(1200),
+		fsxType:            "Lustre",
+		throughputCapacity: decimal.NewFromFloat(0),
+		deploymentOption:   "Persistent",
+		// From Usage
+		backupStorage: decimal.NewFromFloat(vals.Usage.BackupStorageGB),
+	}
+
+	if vals.StorageCapacity > 0 {
+		v.storageCapacity = decimal.NewFromFloat(vals.StorageCapacity)
+	}
+
+	var deploymentType string
+	if len(vals.DeploymentType) > 0 {
+		deploymentType = vals.DeploymentType
+	} else {
+		deploymentType = "PERSISTENT_1"
+	}
+
+	if vals.PerUnitStorageThroughput > 0 {
+		v.throughputCapacity = decimal.NewFromFloat(vals.PerUnitStorageThroughput)
+	} else {
+		if v.storageType == "SSD" {
+			if deploymentType == "PERSISTENT_1" {
+				v.throughputCapacity = decimal.NewFromFloat(50)
+			} else {
+				v.throughputCapacity = decimal.NewFromFloat(125)
+			}
+		} else if v.storageType == "HDD" {
+			if deploymentType == "PERSISTENT_1" {
+				v.throughputCapacity = decimal.NewFromFloat(12)
+			} else {
+				v.throughputCapacity = decimal.NewFromFloat(0)
+			}
+		}
+	}
+
+	if len(vals.StorageType) > 0 {
+		v.storageType = vals.StorageType
+	}
+
+	if vals.AutomaticBackupRetentionDays > 0 {
+		v.automaticBackupRetentionDays = decimal.NewFromFloat(vals.AutomaticBackupRetentionDays)
+	}
+
+	return v
+}
diff --git a/aws/terraform/fsx_ontap_file_system.go b/aws/terraform/fsx_ontap_file_system.go
new file mode 100644
index 0000000..88e0c22
--- /dev/null
+++ b/aws/terraform/fsx_ontap_file_system.go
@@ -0,0 +1,95 @@
+package terraform
+
+import (
+	"strings"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/shopspring/decimal"
+
+	"github.com/cycloidio/terracost/terraform"
+)
+
+// fsxOntapFileSystemValues represents the structure of Terraform values for aws_efs_file_system resource.
+type fsxOntapFileSystemValues struct {
+	StorageCapacity              float64 `mapstructure:"storage_capacity"`
+	StorageType                  string  `mapstructure:"storage_type"`
+	DeploymentType               string  `mapstructure:"deployment_type"`
+	ThroughputCapacity           float64 `mapstructure:"throughput_capacity"`
+	AutomaticBackupRetentionDays float64 `mapstructure:"automatic_backup_retention_days"`
+
+	DiskIopsConfiguration []struct {
+		IOPS     float64 `mapstructure:"iops"`
+		IOPSMode string  `mapstructure:"mode"`
+	} `mapstructure:"disk_iops_configuration"`
+
+	DataCompressionType string `mapstructure:"data_compression_type"`
+
+	Usage struct {
+		BackupStorageGB float64 `mapstructure:"backup_storage_gb"`
+	} `mapstructure:"tc_usage"`
+}
+
+// decodeFSxOntapFileSystemValues decodes and returns fsxOntapFileSystemValues from a Terraform values map.
+func decodeFSxOntapFileSystemValues(tfVals map[string]interface{}) (fsxOntapFileSystemValues, error) {
+	var v fsxOntapFileSystemValues
+	config := &mapstructure.DecoderConfig{
+		WeaklyTypedInput: true,
+		Result:           &v,
+	}
+
+	decoder, err := mapstructure.NewDecoder(config)
+	if err != nil {
+		return v, err
+	}
+
+	if err := decoder.Decode(tfVals); err != nil {
+		return v, err
+	}
+	return v, nil
+}
+
+func (v *FSxFileSystem) getOntapDeployOption(deploymentType string) string {
+
+	deploymentOption := "Multi-AZ"
+	switch strings.ToLower(deploymentType) {
+	case "single_az_1":
+		deploymentOption = "Single-AZ"
+	case "single_az_2":
+		deploymentOption = "Single-AZ_2N"
+	}
+
+	return deploymentOption
+}
+
+// newFSxOntapFileSystem creates a new FSxOntapFileSystem from fsxOntapFileSystemValues.
+func (p *Provider) newFSxOntapFileSystem(rss map[string]terraform.Resource, vals fsxOntapFileSystemValues) *FSxFileSystem {
+	v := &FSxFileSystem{
+		provider:           p,
+		region:             p.region,
+		storageType:        "SSD",
+		storageCapacity:    decimal.NewFromFloat(32),
+		fsxType:            "ONTAP",
+		throughputCapacity: decimal.NewFromFloat(vals.ThroughputCapacity),
+		deploymentOption:   "Single-AZ",
+		// From Usage
+		backupStorage: decimal.NewFromFloat(vals.Usage.BackupStorageGB),
+	}
+
+	if vals.StorageCapacity > 0 {
+		v.storageCapacity = decimal.NewFromFloat(vals.StorageCapacity)
+	}
+
+	if len(vals.DeploymentType) > 0 {
+		v.deploymentOption = v.getOntapDeployOption(vals.DeploymentType)
+	}
+
+	if len(vals.StorageType) > 0 {
+		v.storageType = vals.StorageType
+	}
+
+	if vals.AutomaticBackupRetentionDays > 0 {
+		v.automaticBackupRetentionDays = decimal.NewFromFloat(vals.AutomaticBackupRetentionDays)
+	}
+
+	return v
+}
diff --git a/aws/terraform/fsx_openzfs_file_system.go b/aws/terraform/fsx_openzfs_file_system.go
new file mode 100644
index 0000000..0b38d0b
--- /dev/null
+++ b/aws/terraform/fsx_openzfs_file_system.go
@@ -0,0 +1,95 @@
+package terraform
+
+import (
+	"strings"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/shopspring/decimal"
+
+	"github.com/cycloidio/terracost/terraform"
+)
+
+// fsxOpenzfsFileSystemValues represents the structure of Terraform values for aws_efs_file_system resource.
+type fsxOpenzfsFileSystemValues struct {
+	StorageCapacity              float64 `mapstructure:"storage_capacity"`
+	StorageType                  string  `mapstructure:"storage_type"`
+	DeploymentType               string  `mapstructure:"deployment_type"`
+	ThroughputCapacity           float64 `mapstructure:"throughput_capacity"`
+	AutomaticBackupRetentionDays float64 `mapstructure:"automatic_backup_retention_days"`
+
+	DiskIopsConfiguration []struct {
+		IOPS     float64 `mapstructure:"iops"`
+		IOPSMode string  `mapstructure:"mode"`
+	} `mapstructure:"disk_iops_configuration"`
+
+	DataCompressionType string `mapstructure:"data_compression_type"`
+
+	Usage struct {
+		BackupStorageGB float64 `mapstructure:"backup_storage_gb"`
+	} `mapstructure:"tc_usage"`
+}
+
+// decodeFSxOpenzfsFileSystemValues decodes and returns fsxOpenzfsFileSystemValues from a Terraform values map.
+func decodeFSxOpenzfsFileSystemValues(tfVals map[string]interface{}) (fsxOpenzfsFileSystemValues, error) {
+	var v fsxOpenzfsFileSystemValues
+	config := &mapstructure.DecoderConfig{
+		WeaklyTypedInput: true,
+		Result:           &v,
+	}
+
+	decoder, err := mapstructure.NewDecoder(config)
+	if err != nil {
+		return v, err
+	}
+
+	if err := decoder.Decode(tfVals); err != nil {
+		return v, err
+	}
+	return v, nil
+}
+
+func (v *FSxFileSystem) getOpenzfsDeployOption(deploymentType string) string {
+
+	deploymentOption := "Multi-AZ"
+	switch strings.ToLower(deploymentType) {
+	case "single_az_1":
+		deploymentOption = "Single-AZ"
+	case "single_az_2":
+		deploymentOption = "Single-AZ_2"
+	}
+
+	return deploymentOption
+}
+
+// newFSxOpenzfsFileSystem creates a new FSxOpenzfsFileSystem from fsxOpenzfsFileSystemValues.
+func (p *Provider) newFSxOpenzfsFileSystem(rss map[string]terraform.Resource, vals fsxOpenzfsFileSystemValues) *FSxFileSystem {
+	v := &FSxFileSystem{
+		provider:           p,
+		region:             p.region,
+		storageType:        "SSD",
+		storageCapacity:    decimal.NewFromFloat(32),
+		fsxType:            "OpenZFS",
+		throughputCapacity: decimal.NewFromFloat(vals.ThroughputCapacity),
+		deploymentOption:   "Single-AZ",
+		// From Usage
+		backupStorage: decimal.NewFromFloat(vals.Usage.BackupStorageGB),
+	}
+
+	if vals.StorageCapacity > 0 {
+		v.storageCapacity = decimal.NewFromFloat(vals.StorageCapacity)
+	}
+
+	if len(vals.DeploymentType) > 0 {
+		v.deploymentOption = v.getOpenzfsDeployOption(vals.DeploymentType)
+	}
+
+	if len(vals.StorageType) > 0 {
+		v.storageType = vals.StorageType
+	}
+
+	if vals.AutomaticBackupRetentionDays > 0 {
+		v.automaticBackupRetentionDays = decimal.NewFromFloat(vals.AutomaticBackupRetentionDays)
+	}
+
+	return v
+}
diff --git a/aws/terraform/fsx_windows_file_system.go b/aws/terraform/fsx_windows_file_system.go
new file mode 100644
index 0000000..d5ac7d7
--- /dev/null
+++ b/aws/terraform/fsx_windows_file_system.go
@@ -0,0 +1,90 @@
+package terraform
+
+import (
+	"strings"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/shopspring/decimal"
+
+	"github.com/cycloidio/terracost/terraform"
+)
+
+// fsxWindowsFileSystemValues represents the structure of Terraform values for aws_efs_file_system resource.
+type fsxWindowsFileSystemValues struct {
+	StorageCapacity              float64 `mapstructure:"storage_capacity"`
+	StorageType                  string  `mapstructure:"storage_type"`
+	DeploymentType               string  `mapstructure:"deployment_type"`
+	ThroughputCapacity           float64 `mapstructure:"throughput_capacity"`
+	AutomaticBackupRetentionDays float64 `mapstructure:"automatic_backup_retention_days"`
+
+	Usage struct {
+		BackupStorageGB float64 `mapstructure:"backup_storage_gb"`
+	} `mapstructure:"tc_usage"`
+}
+
+// decodeFSxWindowsFileSystemValues decodes and returns fsxWindowsFileSystemValues from a Terraform values map.
+func decodeFSxWindowsFileSystemValues(tfVals map[string]interface{}) (fsxWindowsFileSystemValues, error) {
+	var v fsxWindowsFileSystemValues
+	config := &mapstructure.DecoderConfig{
+		WeaklyTypedInput: true,
+		Result:           &v,
+	}
+
+	decoder, err := mapstructure.NewDecoder(config)
+	if err != nil {
+		return v, err
+	}
+
+	if err := decoder.Decode(tfVals); err != nil {
+		return v, err
+	}
+	return v, nil
+}
+
+func (v *FSxFileSystem) getWindowsDeployOption(deploymentType string) string {
+
+	deploymentOption := "Multi-AZ"
+	switch strings.ToLower(deploymentType) {
+	// case "multi_az_1":
+	// 	deploymentOption = "Multi-AZ"
+	case "single_az_1":
+		deploymentOption = "Single-AZ"
+	case "single_az_2":
+		deploymentOption = "Single-AZ_2N"
+	}
+
+	return deploymentOption
+}
+
+// newFSxWindowsFileSystem creates a new FSxWindowsFileSystem from fsxWindowsFileSystemValues.
+func (p *Provider) newFSxWindowsFileSystem(rss map[string]terraform.Resource, vals fsxWindowsFileSystemValues) *FSxFileSystem {
+	v := &FSxFileSystem{
+		provider:           p,
+		region:             p.region,
+		storageType:        "SSD",
+		storageCapacity:    decimal.NewFromFloat(32),
+		fsxType:            "Windows",
+		throughputCapacity: decimal.NewFromFloat(vals.ThroughputCapacity),
+		deploymentOption:   "Single-AZ",
+		// From Usage
+		backupStorage: decimal.NewFromFloat(vals.Usage.BackupStorageGB),
+	}
+
+	if vals.StorageCapacity > 0 {
+		v.storageCapacity = decimal.NewFromFloat(vals.StorageCapacity)
+	}
+
+	if len(vals.DeploymentType) > 0 {
+		v.deploymentOption = v.getWindowsDeployOption(vals.DeploymentType)
+	}
+
+	if len(vals.StorageType) > 0 {
+		v.storageType = vals.StorageType
+	}
+
+	if vals.AutomaticBackupRetentionDays > 0 {
+		v.automaticBackupRetentionDays = decimal.NewFromFloat(vals.AutomaticBackupRetentionDays)
+	}
+
+	return v
+}
diff --git a/aws/terraform/fsx_x_file_system.go b/aws/terraform/fsx_x_file_system.go
new file mode 100644
index 0000000..bb32b35
--- /dev/null
+++ b/aws/terraform/fsx_x_file_system.go
@@ -0,0 +1,135 @@
+package terraform
+
+import (
+	"fmt"
+
+	"github.com/shopspring/decimal"
+
+	"github.com/cycloidio/terracost/aws/region"
+	"github.com/cycloidio/terracost/product"
+	"github.com/cycloidio/terracost/query"
+	"github.com/cycloidio/terracost/util"
+)
+
+// FSxFileSystem represents an EFS that can be cost-estimated.
+type FSxFileSystem struct {
+	provider *Provider
+	region   region.Code
+
+	storageCapacity              decimal.Decimal
+	storageType                  string
+	deploymentType               string
+	throughputCapacity           decimal.Decimal
+	automaticBackupRetentionDays decimal.Decimal
+
+	// Used to defined if Windows/Lustre/Openzfs
+	fsxType          string
+	deploymentOption string
+
+	// Usage
+	backupStorage decimal.Decimal
+}
+
+// Components returns the price component queries that make up the FSxFileSystem.
+func (v *FSxFileSystem) Components() []query.Component {
+	components := []query.Component{v.fsxFileSystemStorageCapacityCostComponent()}
+
+	if v.fsxType != "Lustre" {
+		components = append(components, v.fsxFileSystemThroughputCapacityCostComponent())
+	}
+
+	if v.automaticBackupRetentionDays.GreaterThan(decimal.NewFromInt(0)) {
+		components = append(components, v.fsxFileSystemBackupGBCostComponent())
+	}
+
+	return components
+}
+
+func (v *FSxFileSystem) fsxFileSystemThroughputCapacityCostComponent() query.Component {
+	return query.Component{
+		Name:            "Throughput capacity",
+		MonthlyQuantity: v.throughputCapacity,
+		Unit:            "MiBps-Mo",
+		Details:         []string{"Throughput capacity", v.fsxType},
+		Usage:           false,
+		ProductFilter: &product.Filter{
+			Provider: util.StringPtr(v.provider.key),
+			Service:  util.StringPtr("AmazonFSx"),
+			Family:   util.StringPtr("Provisioned Throughput"),
+			Location: util.StringPtr(v.region.String()),
+			AttributeFilters: []*product.AttributeFilter{
+				{Key: "Deployment_option", Value: util.StringPtr(v.deploymentOption)},
+				{Key: "FileSystemType", Value: util.StringPtr(v.fsxType)},
+			},
+		},
+	}
+}
+
+func (v *FSxFileSystem) fsxFileSystemStorageCapacityCostComponent() query.Component {
+
+	attrFilters := []*product.AttributeFilter{
+		{Key: "Deployment_option", Value: util.StringPtr(v.deploymentOption)},
+		{Key: "FileSystemType", Value: util.StringPtr(v.fsxType)},
+		{Key: "StorageType", Value: util.StringPtr(v.storageType)},
+	}
+
+	if v.fsxType == "Lustre" {
+		f := &product.AttributeFilter{Key: "ThroughputCapacity", Value: util.StringPtr(v.throughputCapacity.String())}
+		attrFilters = append(attrFilters, f)
+	}
+
+	return query.Component{
+		Name:            fmt.Sprintf("%s Storage %s", v.fsxType, v.storageType),
+		MonthlyQuantity: v.storageCapacity,
+		Unit:            "GB-Mo",
+		Details:         []string{"Storage", v.fsxType},
+		Usage:           false,
+		ProductFilter: &product.Filter{
+			Provider:         util.StringPtr(v.provider.key),
+			Service:          util.StringPtr("AmazonFSx"),
+			Family:           util.StringPtr("Storage"),
+			Location:         util.StringPtr(v.region.String()),
+			AttributeFilters: attrFilters,
+		},
+	}
+}
+
+func (v *FSxFileSystem) fsxFileSystemBackupGBCostComponent() query.Component {
+	deploymentOption := v.deploymentOption
+	if v.fsxType == "ONTAP" {
+		deploymentOption = "N/A"
+	}
+	if v.fsxType == "OpenZFS" {
+		if v.deploymentOption == "Multi-AZ" {
+			deploymentOption = "Multi-AZ"
+		} else {
+			deploymentOption = "N/A"
+		}
+	}
+	if v.fsxType == "Windows" {
+		if v.deploymentOption == "Multi-AZ" {
+			deploymentOption = "Multi-AZ"
+		} else {
+			deploymentOption = "Single-AZ"
+		}
+	}
+
+	return query.Component{
+		Name:            fmt.Sprintf("%s Backup storage", v.fsxType),
+		MonthlyQuantity: v.storageCapacity,
+		Unit:            "GB-Mo",
+		Details:         []string{"Storage", v.fsxType},
+		Usage:           true,
+		ProductFilter: &product.Filter{
+			Provider: util.StringPtr(v.provider.key),
+			Service:  util.StringPtr("AmazonFSx"),
+			Family:   util.StringPtr("Storage"),
+			Location: util.StringPtr(v.region.String()),
+			AttributeFilters: []*product.AttributeFilter{
+				{Key: "Deployment_option", Value: util.StringPtr(deploymentOption)},
+				{Key: "FileSystemType", Value: util.StringPtr(v.fsxType)},
+				{Key: "UsageType", ValueRegex: util.StringPtr(".*-BackupUsage")},
+			},
+		},
+	}
+}
diff --git a/aws/terraform/provider.go b/aws/terraform/provider.go
index eff553e..64f7f9e 100644
--- a/aws/terraform/provider.go
+++ b/aws/terraform/provider.go
@@ -41,6 +41,12 @@ func (p *Provider) ResourceComponents(rss map[string]terraform.Resource, tfRes t
 			return nil
 		}
 		return p.newAutoscalingGroup(rss, vals).Components()
+	case "aws_db_instance":
+		vals, err := decodeDBInstanceValues(tfRes.Values)
+		if err != nil {
+			return nil
+		}
+		return p.newDBInstance(vals).Components()
 	case "aws_ebs_volume":
 		vals, err := decodeVolumeValues(tfRes.Values)
 		if err != nil {
@@ -71,12 +77,6 @@ func (p *Provider) ResourceComponents(rss map[string]terraform.Resource, tfRes t
 			return nil
 		}
 		return p.newElasticIP(vals).Components()
-	case "aws_db_instance":
-		vals, err := decodeDBInstanceValues(tfRes.Values)
-		if err != nil {
-			return nil
-		}
-		return p.newDBInstance(vals).Components()
 	case "aws_elb":
 		// ELB Classic does not have any special configuration.
 		vals := lbValues{LoadBalancerType: "classic"}
@@ -93,6 +93,30 @@ func (p *Provider) ResourceComponents(rss map[string]terraform.Resource, tfRes t
 			return nil
 		}
 		return p.newEKSNodeGroup(rss, vals).Components()
+	case "aws_fsx_lustre_file_system":
+		vals, err := decodeFSxLustreFileSystemValues(tfRes.Values)
+		if err != nil {
+			return nil
+		}
+		return p.newFSxLustreFileSystem(rss, vals).Components()
+	case "aws_fsx_ontap_file_system":
+		vals, err := decodeFSxOntapFileSystemValues(tfRes.Values)
+		if err != nil {
+			return nil
+		}
+		return p.newFSxOntapFileSystem(rss, vals).Components()
+	case "aws_fsx_openzfs_file_system":
+		vals, err := decodeFSxOpenzfsFileSystemValues(tfRes.Values)
+		if err != nil {
+			return nil
+		}
+		return p.newFSxOpenzfsFileSystem(rss, vals).Components()
+	case "aws_fsx_windows_file_system":
+		vals, err := decodeFSxWindowsFileSystemValues(tfRes.Values)
+		if err != nil {
+			return nil
+		}
+		return p.newFSxWindowsFileSystem(rss, vals).Components()
 	case "aws_lb", "aws_alb":
 		vals, err := decodeLBValues(tfRes.Values)
 		if err != nil {
diff --git a/examples/README.md b/examples/README.md
index 039ffb7..d877fc7 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -9,7 +9,7 @@ Examples help you to understand how to test TerraCost.
 Cloud Provider pricing data need to be ingested in a Mysql server. For testing purpose, local docker can be used
 
 ```
-docker run  -p 3306:3306 -d --privileged  -e MYSQL_ROOT_PASSWORD=terracost  mysql:8.0.21 --default-authentication-plugin=mysql_native_password
+docker run  -p 3306:3306 -d --privileged  -e MYSQL_ROOT_PASSWORD=terracost  mysql:8.0.34 --default-authentication-plugin=mysql_native_password
 ```
 
 Once Mysql started, create the terracost database
@@ -24,7 +24,7 @@ mysql -h 127.0.0.1 -uroot -pterracost -e "CREATE DATABASE terracost_test"
 To start prices ingestion you need to first decide which cloud provider to ingest. In the example `AWS` is available with `-ingest-aws`.
 
 ```
-go run terracost.go -ingest-aws
+go run terracost.go -ingest-aws -minimal
 ```
 
 Here we ingest all supported services by TerraCost, ingestion could takes several minutes depending the amounts of data.
diff --git a/examples/go.mod b/examples/go.mod
index fe5b875..cefbd12 100644
--- a/examples/go.mod
+++ b/examples/go.mod
@@ -71,3 +71,5 @@ require (
 
 // replace github.com/cycloidio/terracost => /opt/go/src/github.com/cycloidio/terracost
 replace github.com/hashicorp/terraform => github.com/cycloidio/terraform v1.1.9-cy
+
+replace github.com/gruntwork-io/terragrunt => github.com/cycloidio/terragrunt v0.0.0-20230905115542-1fe1ff682fd9
diff --git a/examples/terracost.go b/examples/terracost.go
index 8bc6b86..6987932 100644
--- a/examples/terracost.go
+++ b/examples/terracost.go
@@ -142,13 +142,16 @@ func estimateHCL(path string, provider string, backend *mysql.Backend) {
 	}
 
 	// terraform HCL directory
-	planhcl, err := terracost.EstimateHCL(context.Background(), backend, nil, path, usage.Default, terraformAWSProviderInitializer)
+
+	planhcl, err := terracost.EstimateHCL(context.Background(), backend, nil, path, "", false, usage.Default, terraformAWSProviderInitializer)
 	if err != nil {
 		fmt.Printf("%s\n", err)
 		os.Exit(1)
 	}
 
-	estimateDisplay(planhcl)
+	for _, p := range planhcl {
+		estimateDisplay(p)
+	}
 }
 
 func estimateDisplay(resourceDiff *cost.Plan) {
diff --git a/usage/usage.go b/usage/usage.go
index 11a709d..d4f7de9 100644
--- a/usage/usage.go
+++ b/usage/usage.go
@@ -24,6 +24,18 @@ var Default = Usage{
 			"monthly_infrequent_access_read_gb":  20,
 			"monthly_infrequent_access_write_gb": 30,
 		},
+		"aws_fsx_openzfs_file_system": map[string]interface{}{
+			"backup_storage_gb": 1024,
+		},
+		"aws_fsx_windows_file_system": map[string]interface{}{
+			"backup_storage_gb": 1024,
+		},
+		"aws_fsx_ontap_file_system": map[string]interface{}{
+			"backup_storage_gb": 1024,
+		},
+		"aws_fsx_lustre_file_system": map[string]interface{}{
+			"backup_storage_gb": 1024,
+		},
 		"aws_nat_gateway": map[string]interface{}{
 			"monthly_data_processed_gb": 10,
 		},


Test patch:
diff --git a/aws/terraform/fsx_x_file_system_test.go b/aws/terraform/fsx_x_file_system_test.go
new file mode 100644
index 0000000..866e65a
--- /dev/null
+++ b/aws/terraform/fsx_x_file_system_test.go
@@ -0,0 +1,296 @@
+package terraform_test
+
+import (
+	"testing"
+
+	"github.com/shopspring/decimal"
+	"github.com/stretchr/testify/require"
+
+	awstf "github.com/cycloidio/terracost/aws/terraform"
+	"github.com/cycloidio/terracost/product"
+	"github.com/cycloidio/terracost/query"
+	"github.com/cycloidio/terracost/terraform"
+	"github.com/cycloidio/terracost/testutil"
+	"github.com/cycloidio/terracost/usage"
+	"github.com/cycloidio/terracost/util"
+)
+
+func TestFSXXFileSystem_Components(t *testing.T) {
+	p, err := awstf.NewProvider("aws", "eu-west-1")
+	require.NoError(t, err)
+
+	t.Run("LustreFileSystem", func(t *testing.T) {
+		tfres := terraform.Resource{
+			Address:      "aws_fsx_lustre_file_system.test",
+			Type:         "aws_fsx_lustre_file_system",
+			Name:         "test",
+			ProviderName: "aws",
+			Values: map[string]interface{}{
+				"storage_capacity":                float64(1200),
+				"deployment_type":                 "PERSISTENT_2",
+				"per_unit_storage_throughput":     float64(125),
+				"automatic_backup_retention_days": float64(10),
+			},
+		}
+		rss := map[string]terraform.Resource{}
+
+		expected := []query.Component{
+			{
+				Name:            "Lustre Storage SSD",
+				MonthlyQuantity: decimal.NewFromFloat(1200),
+				Unit:            "GB-Mo",
+				Details:         []string{"Storage", "Lustre"},
+				Usage:           false,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Storage"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Persistent")},
+						{Key: "FileSystemType", Value: util.StringPtr("Lustre")},
+						{Key: "StorageType", Value: util.StringPtr("SSD")},
+						{Key: "ThroughputCapacity", Value: util.StringPtr("125")},
+					},
+				},
+			},
+		}
+
+		us := usage.Default.GetUsage("aws_fsx_lustre_file_system")
+		tfres.Values[usage.Key] = us
+		actual := p.ResourceComponents(rss, tfres)
+		testutil.EqualQueryComponents(t, expected, actual)
+	})
+
+	t.Run("OntapFileSystem", func(t *testing.T) {
+		tfres := terraform.Resource{
+			Address:      "aws_fsx_ontap_file_system.test",
+			Type:         "aws_fsx_ontap_file_system",
+			Name:         "test",
+			ProviderName: "aws",
+			Values: map[string]interface{}{
+				"storage_capacity":                float64(1024),
+				"deployment_type":                 "MULTI_AZ_1",
+				"throughput_capacity":             float64(512),
+				"automatic_backup_retention_days": float64(10),
+			},
+		}
+		rss := map[string]terraform.Resource{}
+
+		expected := []query.Component{
+			{
+				Name:            "ONTAP Storage SSD",
+				MonthlyQuantity: decimal.NewFromFloat(1024),
+				Unit:            "GB-Mo",
+				Details:         []string{"Storage", "ONTAP"},
+				Usage:           false,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Storage"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Multi-AZ")},
+						{Key: "FileSystemType", Value: util.StringPtr("ONTAP")},
+						{Key: "StorageType", Value: util.StringPtr("SSD")},
+					},
+				},
+			},
+			{
+				Name:            "Throughput capacity",
+				MonthlyQuantity: decimal.NewFromFloat(512),
+				Unit:            "MiBps-Mo",
+				Details:         []string{"Throughput capacity", "ONTAP"},
+				Usage:           false,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Provisioned Throughput"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Multi-AZ")},
+						{Key: "FileSystemType", Value: util.StringPtr("ONTAP")},
+					},
+				},
+			},
+			{
+				Name:            "ONTAP Backup storage",
+				MonthlyQuantity: decimal.NewFromFloat(1024),
+				Unit:            "GB-Mo",
+				Details:         []string{"Storage", "ONTAP"},
+				Usage:           true,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Storage"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("N/A")},
+						{Key: "FileSystemType", Value: util.StringPtr("ONTAP")},
+						{Key: "UsageType", ValueRegex: util.StringPtr(".*-BackupUsage")},
+					},
+				},
+			},
+		}
+
+		us := usage.Default.GetUsage("aws_fsx_ontap_file_system")
+		tfres.Values[usage.Key] = us
+		actual := p.ResourceComponents(rss, tfres)
+		testutil.EqualQueryComponents(t, expected, actual)
+	})
+
+	t.Run("OpenzfsFileSystem", func(t *testing.T) {
+		tfres := terraform.Resource{
+			Address:      "aws_fsx_openzfs_file_system.test",
+			Type:         "aws_fsx_openzfs_file_system",
+			Name:         "test",
+			ProviderName: "aws",
+			Values: map[string]interface{}{
+				"storage_capacity":                float64(1024),
+				"deployment_type":                 "SINGLE_AZ_1",
+				"throughput_capacity":             float64(64),
+				"automatic_backup_retention_days": float64(10),
+			},
+		}
+		rss := map[string]terraform.Resource{}
+
+		expected := []query.Component{
+			{
+				Name:            "OpenZFS Storage SSD",
+				MonthlyQuantity: decimal.NewFromFloat(1024),
+				Unit:            "GB-Mo",
+				Details:         []string{"Storage", "OpenZFS"},
+				Usage:           false,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Storage"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Single-AZ")},
+						{Key: "FileSystemType", Value: util.StringPtr("OpenZFS")},
+						{Key: "StorageType", Value: util.StringPtr("SSD")},
+					},
+				},
+			},
+			{
+				Name:            "Throughput capacity",
+				MonthlyQuantity: decimal.NewFromFloat(64),
+				Unit:            "MiBps-Mo",
+				Details:         []string{"Throughput capacity", "OpenZFS"},
+				Usage:           false,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Provisioned Throughput"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Single-AZ")},
+						{Key: "FileSystemType", Value: util.StringPtr("OpenZFS")},
+					},
+				},
+			},
+			{
+				Name:            "OpenZFS Backup storage",
+				MonthlyQuantity: decimal.NewFromFloat(1024),
+				Unit:            "GB-Mo",
+				Details:         []string{"Storage", "OpenZFS"},
+				Usage:           true,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Storage"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("N/A")},
+						{Key: "FileSystemType", Value: util.StringPtr("OpenZFS")},
+						{Key: "UsageType", ValueRegex: util.StringPtr(".*-BackupUsage")},
+					},
+				},
+			},
+		}
+
+		us := usage.Default.GetUsage("aws_fsx_openzfs_file_system")
+		tfres.Values[usage.Key] = us
+		actual := p.ResourceComponents(rss, tfres)
+		testutil.EqualQueryComponents(t, expected, actual)
+	})
+
+	t.Run("WindowsFileSystem", func(t *testing.T) {
+		tfres := terraform.Resource{
+			Address:      "aws_fsx_windows_file_system.test",
+			Type:         "aws_fsx_windows_file_system",
+			Name:         "test",
+			ProviderName: "aws",
+			Values: map[string]interface{}{
+				"storage_capacity":                float64(300),
+				"deployment_type":                 "MULTI_AZ_1",
+				"throughput_capacity":             float64(1024),
+				"automatic_backup_retention_days": float64(10),
+			},
+		}
+		rss := map[string]terraform.Resource{}
+
+		expected := []query.Component{
+			{
+				Name:            "Windows Storage SSD",
+				MonthlyQuantity: decimal.NewFromFloat(300),
+				Unit:            "GB-Mo",
+				Details:         []string{"Storage", "Windows"},
+				Usage:           false,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Storage"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Multi-AZ")},
+						{Key: "FileSystemType", Value: util.StringPtr("Windows")},
+						{Key: "StorageType", Value: util.StringPtr("SSD")},
+					},
+				},
+			},
+			{
+				Name:            "Throughput capacity",
+				MonthlyQuantity: decimal.NewFromFloat(1024),
+				Unit:            "MiBps-Mo",
+				Details:         []string{"Throughput capacity", "Windows"},
+				Usage:           false,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Provisioned Throughput"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Multi-AZ")},
+						{Key: "FileSystemType", Value: util.StringPtr("Windows")},
+					},
+				},
+			},
+			{
+				Name:            "Windows Backup storage",
+				MonthlyQuantity: decimal.NewFromFloat(300),
+				Unit:            "GB-Mo",
+				Details:         []string{"Storage", "Windows"},
+				Usage:           true,
+				ProductFilter: &product.Filter{
+					Provider: util.StringPtr("aws"),
+					Service:  util.StringPtr("AmazonFSx"),
+					Family:   util.StringPtr("Storage"),
+					Location: util.StringPtr("eu-west-1"),
+					AttributeFilters: []*product.AttributeFilter{
+						{Key: "Deployment_option", Value: util.StringPtr("Multi-AZ")},
+						{Key: "FileSystemType", Value: util.StringPtr("Windows")},
+						{Key: "UsageType", ValueRegex: util.StringPtr(".*-BackupUsage")},
+					},
+				},
+			},
+		}
+
+		us := usage.Default.GetUsage("aws_fsx_windows_file_system")
+		tfres.Values[usage.Key] = us
+		actual := p.ResourceComponents(rss, tfres)
+		testutil.EqualQueryComponents(t, expected, actual)
+	})
+
+}