terraform-forge 0.1.6

Terraform provider code generator from OpenAPI specs
Documentation
use std::fmt::Write as _;

use crate::spec::ResourceSpec;
use crate::type_map::{to_tf_name, to_type_name};

/// Generated acceptance test file for a resource.
#[derive(Debug, Clone, PartialEq, Eq)]
#[must_use]
pub struct GeneratedTest {
    pub file_name: String,
    pub go_code: String,
}

/// Generate acceptance test scaffolding for a resource.
pub fn generate_test(resource: &ResourceSpec) -> GeneratedTest {
    let type_name = to_type_name(&resource.resource.name);

    let tf_name = &resource.resource.name;
    let file_name = format!("resource_{}_test.go", to_tf_name(tf_name));

    let id_field = &resource.identity.id_field;

    let mut code = String::new();

    let _ = write!(
        code,
        r#"// Code generated by terraform-forge. DO NOT EDIT.

package resources_test

import (
	"fmt"
	"testing"

	"github.com/hashicorp/terraform-plugin-testing/helper/acctest"
	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
)

func TestAcc{type_name}_basic(t *testing.T) {{
	rName := fmt.Sprintf("tf-test-%s", acctest.RandStringFromCharSet(10, acctest.CharSetAlphaNum))

	resource.Test(t, resource.TestCase{{
		PreCheck:                 func() {{ testAccPreCheck(t) }},
		ProtoV6ProviderFactories: testAccProtoV6ProviderFactories,
		Steps: []resource.TestStep{{
			// Create and Read
			{{
				Config: testAcc{type_name}Config_basic(rName),
				Check: resource.ComposeAggregateTestCheckFunc(
					resource.TestCheckResourceAttr("{tf_name}.test", "{id_field}", rName),
				),
			}},
			// ImportState
			{{
				ResourceName:      "{tf_name}.test",
				ImportState:       true,
				ImportStateVerify: true,
"#
    );

    let sensitive_fields: Vec<&str> = resource
        .fields
        .iter()
        .filter(|(_, v)| v.sensitive)
        .map(|(k, _)| k.as_str())
        .collect();

    if !sensitive_fields.is_empty() {
        let quoted: Vec<String> = sensitive_fields
            .iter()
            .map(|f| format!("\"{}\"", to_tf_name(f)))
            .collect();
        code.push_str(&format!(
            "\t\t\t\tImportStateVerifyIgnore: []string{{{}}},\n",
            quoted.join(", ")
        ));
    }

    let _ = write!(
        code,
        r#"			}},
		}},
	}})
}}

func testAcc{type_name}Config_basic(name string) string {{
	return fmt.Sprintf(`
resource "{tf_name}" "test" {{
  {id_field} = "%s"
"#
    );

    code.push_str("  # TODO: Add required fields\n");

    code.push_str(
        r"}}
`, name)
}}
"
    );

    GeneratedTest {
        file_name,
        go_code: code,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn generate_basic_test() {
        let toml_str = r#"
[resource]
name = "akeyless_static_secret"
description = "Static secret"
category = "secret"

[crud]
create_endpoint = "/create-secret"
create_schema = "createSecret"
read_endpoint = "/get-secret-value"
read_schema = "getSecretValue"
delete_endpoint = "/delete-item"
delete_schema = "deleteItem"

[identity]
id_field = "name"
force_new_fields = ["name"]

[fields]
value = { sensitive = true }
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("TestAccStaticSecret_basic"));
        assert!(test.go_code.contains("ImportStateVerifyIgnore"));
        assert!(test.go_code.contains("\"value\""));
        assert_eq!(test.file_name, "resource_akeyless_static_secret_test.go");
    }

    // --- No sensitive fields ---

    #[test]
    fn generate_test_no_sensitive_fields() {
        let toml_str = r#"
[resource]
name = "akeyless_role"
description = "Role"

[crud]
create_endpoint = "/create"
create_schema = "C"
read_endpoint = "/read"
read_schema = "R"
delete_endpoint = "/delete"
delete_schema = "D"

[identity]
id_field = "name"
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("TestAccRole_basic"));
        assert!(
            !test.go_code.contains("ImportStateVerifyIgnore"),
            "No sensitive fields means no ImportStateVerifyIgnore"
        );
        assert_eq!(test.file_name, "resource_akeyless_role_test.go");
    }

    // --- Multiple sensitive fields ---

    #[test]
    fn generate_test_multiple_sensitive_fields() {
        let toml_str = r#"
[resource]
name = "akeyless_creds"
description = "Creds"

[crud]
create_endpoint = "/create"
create_schema = "C"
read_endpoint = "/read"
read_schema = "R"
delete_endpoint = "/delete"
delete_schema = "D"

[identity]
id_field = "name"

[fields]
password = { sensitive = true }
api_key = { sensitive = true }
token = { sensitive = true }
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("ImportStateVerifyIgnore"));
        assert!(test.go_code.contains("\"password\""));
        assert!(test.go_code.contains("\"api_key\""));
        assert!(test.go_code.contains("\"token\""));
    }

    // --- Resource without akeyless_ prefix ---

    #[test]
    fn generate_test_no_prefix() {
        let toml_str = r#"
[resource]
name = "custom_resource"
description = "Custom"

[crud]
create_endpoint = "/create"
create_schema = "C"
read_endpoint = "/read"
read_schema = "R"
delete_endpoint = "/delete"
delete_schema = "D"

[identity]
id_field = "id"
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("TestAccCustomResource_basic"));
        assert!(test.go_code.contains("custom_resource"));
        assert_eq!(test.file_name, "resource_custom_resource_test.go");
    }

    // --- Test scaffold structure ---

    #[test]
    fn generate_test_has_package_declaration() {
        let toml_str = r#"
[resource]
name = "akeyless_thing"

[crud]
create_endpoint = "/c"
create_schema = "C"
read_endpoint = "/r"
read_schema = "R"
delete_endpoint = "/d"
delete_schema = "D"

[identity]
id_field = "name"
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("package resources_test"));
    }

    #[test]
    fn generate_test_has_imports() {
        let toml_str = r#"
[resource]
name = "akeyless_thing"

[crud]
create_endpoint = "/c"
create_schema = "C"
read_endpoint = "/r"
read_schema = "R"
delete_endpoint = "/d"
delete_schema = "D"

[identity]
id_field = "name"
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("\"testing\""));
        assert!(test.go_code.contains("acctest.RandStringFromCharSet"));
    }

    #[test]
    fn generate_test_has_todo_for_required_fields() {
        let toml_str = r#"
[resource]
name = "akeyless_thing"

[crud]
create_endpoint = "/c"
create_schema = "C"
read_endpoint = "/r"
read_schema = "R"
delete_endpoint = "/d"
delete_schema = "D"

[identity]
id_field = "name"
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("# TODO: Add required fields"));
    }

    #[test]
    fn generate_test_uses_id_field_in_check() {
        let toml_str = r#"
[resource]
name = "akeyless_item"

[crud]
create_endpoint = "/c"
create_schema = "C"
read_endpoint = "/r"
read_schema = "R"
delete_endpoint = "/d"
delete_schema = "D"

[identity]
id_field = "path"
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(
            test.go_code.contains("\"path\", rName"),
            "TestCheckResourceAttr should use the id_field"
        );
        assert!(test.go_code.contains("path = \"%s\""));
    }

    #[test]
    fn generate_test_has_import_state_step() {
        let toml_str = r#"
[resource]
name = "akeyless_thing"

[crud]
create_endpoint = "/c"
create_schema = "C"
read_endpoint = "/r"
read_schema = "R"
delete_endpoint = "/d"
delete_schema = "D"

[identity]
id_field = "name"
"#;
        let resource: ResourceSpec = toml::from_str(toml_str).expect("parse");
        let test = generate_test(&resource);
        assert!(test.go_code.contains("ImportState:       true"));
        assert!(test.go_code.contains("ImportStateVerify: true"));
    }
}