chore: fixes all the lints errors

Author: PacoDw

mongodbatlas/data_source_mongodbatlas_alert_configuration.go

@@ -197,18 +197,23 @@ func dataSourceMongoDBAtlasAlertConfigurationRead(d *schema.ResourceData, meta i
 	if err := d.Set("event_type", alert.EventTypeName); err != nil {
 		return fmt.Errorf(errorAlertConfSetting, "event_type", projectID, err)
 	}
+
 	if err := d.Set("created", alert.Created); err != nil {
 		return fmt.Errorf(errorAlertConfSetting, "created", projectID, err)
 	}
+
 	if err := d.Set("updated", alert.Updated); err != nil {
 		return fmt.Errorf(errorAlertConfSetting, "updated", projectID, err)
 	}
+
 	if err := d.Set("matcher", flattenAlertConfigurationMatchers(alert.Matchers)); err != nil {
 		return fmt.Errorf(errorAlertConfSetting, "matcher", projectID, err)
 	}
+
 	if err := d.Set("metric_threshold", flattenAlertConfigurationMetricThreshold(alert.MetricThreshold)); err != nil {
 		return fmt.Errorf(errorAlertConfSetting, "metric_threshold", projectID, err)
 	}
+
 	if err := d.Set("notification", flattenAlertConfigurationNotifications(alert.Notifications)); err != nil {
 		return fmt.Errorf(errorAlertConfSetting, "notification", projectID, err)
 	}

mongodbatlas/data_source_mongodbatlas_alert_configuration_test.go

@@ -10,10 +10,11 @@ import (
 )
 
 func TestAccDataSourceMongoDBAtlaAlertConfiguration_basic(t *testing.T) {
-	var alert = &matlas.AlertConfiguration{}
-
-	dataSourceName := "data.mongodbatlas_alert_configuration.test"
-	projectID := os.Getenv("MONGODB_ATLAS_PROJECT_ID")
+	var (
+		alert          = &matlas.AlertConfiguration{}
+		dataSourceName = "data.mongodbatlas_alert_configuration.test"
+		projectID      = os.Getenv("MONGODB_ATLAS_PROJECT_ID")
+	)
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:     func() { testAccPreCheck(t) },
@@ -29,7 +30,6 @@ func TestAccDataSourceMongoDBAtlaAlertConfiguration_basic(t *testing.T) {
 			},
 		},
 	})
-
 }
 
 func testAccDSMongoDBAtlasAlertConfiguration(projectID string) string {
@@ -38,21 +38,21 @@ func testAccDSMongoDBAtlasAlertConfiguration(projectID string) string {
 			project_id = "%s"
 			event_type = "OUTSIDE_METRIC_THRESHOLD"
 			enabled    = true
-		
+
 			notification {
 				type_name     = "GROUP"
 				interval_min  = 5
 				delay_min     = 0
 				sms_enabled   = false
 				email_enabled = true
 			}
-		
+
 			matcher {
 				field_name = "HOSTNAME_AND_PORT"
 				operator   = "EQUALS"
 				value      = "SECONDARY"
 			}
-		
+
 			metric_threshold = {
 				metric_name = "ASSERT_REGULAR"
 				operator    = "LESS_THAN"
@@ -61,7 +61,7 @@ func testAccDSMongoDBAtlasAlertConfiguration(projectID string) string {
 				mode        = "AVERAGE"
 			}
 		}
-		
+
 		data "mongodbatlas_alert_configuration" "test" {
 			project_id             = "${mongodbatlas_alert_configuration.test.project_id}"
 			alert_configuration_id = "${mongodbatlas_alert_configuration.test.alert_configuration_id}"

mongodbatlas/data_source_mongodbatlas_auditing.go

@@ -39,7 +39,6 @@ func dataSourceMongoDBAtlasAuditing() *schema.Resource {
 
 func dataSourceMongoDBAtlasAuditingRead(d *schema.ResourceData, meta interface{}) error {
 	conn := meta.(*matlas.Client)
-
 	projectID := d.Get("project_id").(string)
 
 	auditing, _, err := conn.Auditing.Get(context.Background(), projectID)
@@ -50,16 +49,20 @@ func dataSourceMongoDBAtlasAuditingRead(d *schema.ResourceData, meta interface{}
 	if err := d.Set("audit_authorization_success", auditing.AuditAuthorizationSuccess); err != nil {
 		return fmt.Errorf(errorAuditingRead, projectID, err)
 	}
+
 	if err := d.Set("audit_filter", auditing.AuditFilter); err != nil {
 		return fmt.Errorf(errorAuditingRead, projectID, err)
 	}
+
 	if err := d.Set("enabled", auditing.Enabled); err != nil {
 		return fmt.Errorf(errorAuditingRead, projectID, err)
 	}
+
 	if err := d.Set("configuration_type", auditing.ConfigurationType); err != nil {
 		return fmt.Errorf(errorAuditingRead, projectID, err)
 	}
 
 	d.SetId(projectID)
+
 	return nil
 }

mongodbatlas/data_source_mongodbatlas_auditing_test.go

@@ -10,13 +10,14 @@ import (
 )
 
 func TestAccDataSourceMongoDBAtlasAuditing_basic(t *testing.T) {
-	var auditing matlas.Auditing
-	dataSourceName := "data.mongodbatlas_auditing.test"
-
-	projectID := os.Getenv("MONGODB_ATLAS_PROJECT_ID")
-	auditAuth := true
-	auditFilter := "{ 'atype': 'authenticate', 'param': {   'user': 'auditAdmin',   'db': 'admin',   'mechanism': 'SCRAM-SHA-1' }}"
-	enabled := true
+	var (
+		auditing       matlas.Auditing
+		dataSourceName = "data.mongodbatlas_auditing.test"
+		projectID      = os.Getenv("MONGODB_ATLAS_PROJECT_ID")
+		auditAuth      = true
+		auditFilter    = "{ 'atype': 'authenticate', 'param': {   'user': 'auditAdmin',   'db': 'admin',   'mechanism': 'SCRAM-SHA-1' }}"
+		enabled        = true
+	)
 
 	resource.ParallelTest(t, resource.TestCase{
 		PreCheck:  func() { testAccPreCheck(t) },

mongodbatlas/data_source_mongodbatlas_cloud_provider_snapshot.go

@@ -82,27 +82,35 @@ func dataSourceMongoDBAtlasCloudProviderSnapshotRead(d *schema.ResourceData, met
 	if err = d.Set("created_at", snapshotRes.CreatedAt); err != nil {
 		return fmt.Errorf("error setting `created_at` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("description", snapshotRes.Description); err != nil {
 		return fmt.Errorf("error setting `description` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("expires_at", snapshotRes.ExpiresAt); err != nil {
 		return fmt.Errorf("error setting `expires_at` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("master_key_uuid", snapshotRes.MasterKeyUUID); err != nil {
 		return fmt.Errorf("error setting `master_key_uuid` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("mongod_version", snapshotRes.MongodVersion); err != nil {
 		return fmt.Errorf("error setting `mongod_version` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("snapshot_type", snapshotRes.SnapshotType); err != nil {
 		return fmt.Errorf("error setting `snapshot_type` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("status", snapshotRes.Status); err != nil {
 		return fmt.Errorf("error setting `status` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("storage_size_bytes", snapshotRes.StorageSizeBytes); err != nil {
 		return fmt.Errorf("error setting `storage_size_bytes` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("type", snapshotRes.Type); err != nil {
 		return fmt.Errorf("error setting `type` for cloudProviderSnapshot (%s): %s", d.Id(), err)
 	}

mongodbatlas/data_source_mongodbatlas_cloud_provider_snapshot_backup_policy.go

@@ -103,21 +103,27 @@ func dataSourceMongoDBAtlasCloudProviderSnapshotBackupPolicyRead(d *schema.Resou
 	if err := d.Set("cluster_id", backupPolicy.ClusterID); err != nil {
 		return fmt.Errorf(errorSnapshotBackupPolicySetting, "cluster_id", clusterName, err)
 	}
+
 	if err := d.Set("reference_hour_of_day", backupPolicy.ReferenceHourOfDay); err != nil {
 		return fmt.Errorf(errorSnapshotBackupPolicySetting, "reference_hour_of_day", clusterName, err)
 	}
+
 	if err := d.Set("reference_minute_of_hour", backupPolicy.ReferenceMinuteOfHour); err != nil {
 		return fmt.Errorf(errorSnapshotBackupPolicySetting, "reference_minute_of_hour", clusterName, err)
 	}
+
 	if err := d.Set("restore_window_days", backupPolicy.RestoreWindowDays); err != nil {
 		return fmt.Errorf(errorSnapshotBackupPolicySetting, "restore_window_days", clusterName, err)
 	}
+
 	if err := d.Set("update_snapshots", backupPolicy.UpdateSnapshots); err != nil {
 		return fmt.Errorf(errorSnapshotBackupPolicySetting, "update_snapshots", clusterName, err)
 	}
+
 	if err := d.Set("next_snapshot", backupPolicy.NextSnapshot); err != nil {
 		return fmt.Errorf(errorSnapshotBackupPolicySetting, "next_snapshot", clusterName, err)
 	}
+
 	if err := d.Set("policies", flattenPolicies(backupPolicy.Policies)); err != nil {
 		return fmt.Errorf(errorSnapshotBackupPolicySetting, "policies", clusterName, err)
 	}

mongodbatlas/data_source_mongodbatlas_cloud_provider_snapshot_restore_job.go

@@ -108,42 +108,55 @@ func dataSourceMongoDBAtlasCloudProviderSnapshotRestoreJobRead(d *schema.Resourc
 	if err = d.Set("cancelled", snapshotRes.Cancelled); err != nil {
 		return fmt.Errorf("error setting `cancelled` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("created_at", snapshotRes.CreatedAt); err != nil {
 		return fmt.Errorf("error setting `created_at` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("delivery_type", snapshotRes.DeliveryType); err != nil {
 		return fmt.Errorf("error setting `delivery_type` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("delivery_url", snapshotRes.DeliveryURL); err != nil {
 		return fmt.Errorf("error setting `delivery_url` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("expired", snapshotRes.Expired); err != nil {
 		return fmt.Errorf("error setting `expired` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("expires_at", snapshotRes.ExpiresAt); err != nil {
 		return fmt.Errorf("error setting `expires_at` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("finished_at", snapshotRes.FinishedAt); err != nil {
 		return fmt.Errorf("error setting `finished_at` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("snapshot_id", snapshotRes.SnapshotID); err != nil {
 		return fmt.Errorf("error setting `snapshotId` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("target_project_id", snapshotRes.TargetGroupID); err != nil {
 		return fmt.Errorf("error setting `targetGroupId` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("target_cluster_name", snapshotRes.TargetClusterName); err != nil {
 		return fmt.Errorf("error setting `targetClusterName` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("timestamp", snapshotRes.Timestamp); err != nil {
 		return fmt.Errorf("error setting `timestamp` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("oplog_ts", snapshotRes.OplogTs); err != nil {
 		return fmt.Errorf("error setting `oplog_ts` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("point_in_time_utc_seconds", snapshotRes.PointInTimeUTCSeconds); err != nil {
 		return fmt.Errorf("error setting `point_in_time_utc_seconds` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}
+
 	if err = d.Set("oplog_inc", snapshotRes.OplogInc); err != nil {
 		return fmt.Errorf("error setting `oplog_inc` for cloudProviderSnapshotRestoreJob (%s): %s", d.Id(), err)
 	}

mongodbatlas/data_source_mongodbatlas_cloud_provider_snapshot_restore_jobs.go

@@ -125,14 +125,17 @@ func dataSourceMongoDBAtlasCloudProviderSnapshotRestoreJobsRead(d *schema.Resour
 	if err != nil {
 		return fmt.Errorf("error getting cloudProviderSnapshotRestoreJobs information: %s", err)
 	}
+
 	if err := d.Set("results", flattenCloudProviderSnapshotRestoreJobs(cloudProviderSnapshotRestoreJobs.Results)); err != nil {
 		return fmt.Errorf("error setting `results`: %s", err)
 	}
+
 	if err := d.Set("total_count", cloudProviderSnapshotRestoreJobs.TotalCount); err != nil {
 		return fmt.Errorf("error setting `total_count`: %s", err)
 	}
 
 	d.SetId(resource.UniqueId())
+
 	return nil
 }
 
@@ -162,5 +165,6 @@ func flattenCloudProviderSnapshotRestoreJobs(cloudProviderSnapshotRestoreJobs []
 			}
 		}
 	}
+
 	return results
 }

mongodbatlas/data_source_mongodbatlas_cloud_provider_snapshots.go

@@ -103,14 +103,17 @@ func dataSourceMongoDBAtlasCloudProviderSnapshotsRead(d *schema.ResourceData, me
 	if err != nil {
 		return fmt.Errorf("error getting cloudProviderSnapshots information: %s", err)
 	}
+
 	if err := d.Set("results", flattenCloudProviderSnapshots(cloudProviderSnapshots.Results)); err != nil {
 		return fmt.Errorf("error setting `results`: %s", err)
 	}
+
 	if err := d.Set("total_count", cloudProviderSnapshots.TotalCount); err != nil {
 		return fmt.Errorf("error setting `total_count`: %s", err)
 	}
 
 	d.SetId(resource.UniqueId())
+
 	return nil
 }
 
@@ -135,5 +138,6 @@ func flattenCloudProviderSnapshots(cloudProviderSnapshots []*matlas.CloudProvide
 			}
 		}
 	}
+
 	return results
 }