Skip to main content

terraform_forge/
spec.rs

1use std::collections::BTreeMap;
2use std::path::Path;
3
4use serde::{Deserialize, Serialize};
5
6use crate::error::ForgeError;
7
8/// Top-level resource specification loaded from TOML.
9#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
10pub struct ResourceSpec {
11    pub resource: ResourceMeta,
12    pub crud: CrudMapping,
13    pub identity: IdentityConfig,
14    #[serde(default)]
15    pub fields: BTreeMap<String, FieldOverride>,
16    #[serde(default)]
17    pub read_mapping: BTreeMap<String, String>,
18}
19
20/// Resource metadata.
21#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
22pub struct ResourceMeta {
23    pub name: String,
24    #[serde(default)]
25    pub description: String,
26    #[serde(default)]
27    pub category: String,
28}
29
30/// Maps CRUD operations to API endpoints and schemas.
31#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
32pub struct CrudMapping {
33    pub create_endpoint: String,
34    pub create_schema: String,
35    #[serde(default)]
36    pub update_endpoint: Option<String>,
37    #[serde(default)]
38    pub update_schema: Option<String>,
39    pub read_endpoint: String,
40    pub read_schema: String,
41    #[serde(default)]
42    pub read_response_schema: Option<String>,
43    pub delete_endpoint: String,
44    pub delete_schema: String,
45}
46
47/// Identity and import configuration.
48#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
49pub struct IdentityConfig {
50    pub id_field: String,
51    #[serde(default)]
52    pub import_field: Option<String>,
53    #[serde(default)]
54    pub force_new_fields: Vec<String>,
55}
56
57/// Per-field overrides in the resource spec.
58#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
59#[allow(clippy::struct_excessive_bools)]
60pub struct FieldOverride {
61    #[serde(default)]
62    pub computed: bool,
63    #[serde(default)]
64    pub sensitive: bool,
65    #[serde(default)]
66    pub skip: bool,
67    #[serde(default)]
68    pub type_override: Option<String>,
69    #[serde(default)]
70    pub description: Option<String>,
71    #[serde(default)]
72    pub force_new: bool,
73}
74
75/// Provider-level configuration.
76#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
77pub struct ProviderSpec {
78    pub provider: ProviderMeta,
79    #[serde(default)]
80    pub auth: AuthConfig,
81    #[serde(default)]
82    pub defaults: ProviderDefaults,
83}
84
85/// Provider metadata (name, description, version, SDK import).
86#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
87pub struct ProviderMeta {
88    pub name: String,
89    #[serde(default)]
90    pub description: String,
91    #[serde(default)]
92    pub version: String,
93    #[serde(default)]
94    pub sdk_import: String,
95}
96
97/// Provider authentication configuration (token field, environment variables).
98#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
99pub struct AuthConfig {
100    #[serde(default)]
101    pub token_field: String,
102    #[serde(default)]
103    pub env_var: String,
104    #[serde(default)]
105    pub gateway_url_field: String,
106    #[serde(default)]
107    pub gateway_env_var: String,
108}
109
110/// Provider-level default settings (fields to skip globally).
111#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
112pub struct ProviderDefaults {
113    #[serde(default)]
114    pub skip_fields: Vec<String>,
115}
116
117impl ResourceSpec {
118    /// Load a resource spec from a TOML file.
119    ///
120    /// # Errors
121    ///
122    /// Returns an error if the file can't be read or parsed.
123    pub fn load(path: &Path) -> Result<Self, ForgeError> {
124        let content = std::fs::read_to_string(path)?;
125        let spec: Self = toml::from_str(&content)?;
126        Ok(spec)
127    }
128
129    /// Validate the resource spec against an `OpenAPI` spec.
130    ///
131    /// # Errors
132    ///
133    /// Returns validation errors if schemas are missing or endpoints don't exist.
134    pub fn validate(&self, api: &openapi_forge::Spec) -> Result<(), ForgeError> {
135        // Validate that referenced schemas exist
136        api.schema(&self.crud.create_schema)
137            .map_err(|_| ForgeError::SchemaNotFound(self.crud.create_schema.clone()))?;
138
139        api.schema(&self.crud.read_schema)
140            .map_err(|_| ForgeError::SchemaNotFound(self.crud.read_schema.clone()))?;
141
142        api.schema(&self.crud.delete_schema)
143            .map_err(|_| ForgeError::SchemaNotFound(self.crud.delete_schema.clone()))?;
144
145        if let Some(ref update_schema) = self.crud.update_schema {
146            api.schema(update_schema)
147                .map_err(|_| ForgeError::SchemaNotFound(update_schema.clone()))?;
148        }
149
150        if let Some(ref response_schema) = self.crud.read_response_schema {
151            api.schema(response_schema)
152                .map_err(|_| ForgeError::SchemaNotFound(response_schema.clone()))?;
153        }
154
155        // Validate endpoints exist
156        if api.endpoint_by_path(&self.crud.create_endpoint).is_none() {
157            return Err(ForgeError::MissingEndpoint {
158                resource: self.resource.name.clone(),
159                endpoint: self.crud.create_endpoint.clone(),
160            });
161        }
162
163        Ok(())
164    }
165}
166
167impl ProviderSpec {
168    /// Load a provider spec from a TOML file.
169    ///
170    /// # Errors
171    ///
172    /// Returns an error if the file can't be read or parsed.
173    pub fn load(path: &Path) -> Result<Self, ForgeError> {
174        let content = std::fs::read_to_string(path)?;
175        let spec: Self = toml::from_str(&content)?;
176        Ok(spec)
177    }
178}
179
180/// Top-level data source specification loaded from TOML.
181#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
182pub struct DataSourceSpec {
183    pub data_source: DataSourceMeta,
184    pub read: ReadMapping,
185    #[serde(default)]
186    pub fields: BTreeMap<String, FieldOverride>,
187    #[serde(default)]
188    pub read_mapping: BTreeMap<String, String>,
189}
190
191/// Data source metadata.
192#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
193pub struct DataSourceMeta {
194    pub name: String,
195    #[serde(default)]
196    pub description: String,
197}
198
199/// Maps a read operation to an API endpoint and schema.
200#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
201pub struct ReadMapping {
202    pub endpoint: String,
203    pub schema: String,
204    #[serde(default)]
205    pub response_schema: Option<String>,
206}
207
208impl DataSourceSpec {
209    /// Load a data source spec from a TOML file.
210    ///
211    /// # Errors
212    ///
213    /// Returns an error if the file can't be read or parsed.
214    pub fn load(path: &Path) -> Result<Self, ForgeError> {
215        let content = std::fs::read_to_string(path)?;
216        let spec: Self = toml::from_str(&content)?;
217        Ok(spec)
218    }
219
220    /// Validate the data source spec against an `OpenAPI` spec.
221    ///
222    /// # Errors
223    ///
224    /// Returns validation errors if schemas are missing or endpoints don't exist.
225    pub fn validate(&self, api: &openapi_forge::Spec) -> Result<(), ForgeError> {
226        api.schema(&self.read.schema)
227            .map_err(|_| ForgeError::SchemaNotFound(self.read.schema.clone()))?;
228
229        if let Some(ref response_schema) = self.read.response_schema {
230            api.schema(response_schema)
231                .map_err(|_| ForgeError::SchemaNotFound(response_schema.clone()))?;
232        }
233
234        if api.endpoint_by_path(&self.read.endpoint).is_none() {
235            return Err(ForgeError::MissingEndpoint {
236                resource: self.data_source.name.clone(),
237                endpoint: self.read.endpoint.clone(),
238            });
239        }
240
241        Ok(())
242    }
243}
244
245#[cfg(test)]
246mod tests {
247    use super::*;
248
249    #[test]
250    fn parse_resource_spec() {
251        let toml_str = r#"
252[resource]
253name = "akeyless_static_secret"
254description = "Static secret"
255category = "secret"
256
257[crud]
258create_endpoint = "/create-secret"
259create_schema = "createSecret"
260update_endpoint = "/update-secret-val"
261update_schema = "updateSecretVal"
262read_endpoint = "/get-secret-value"
263read_schema = "getSecretValue"
264read_response_schema = "GetSecretValueOutput"
265delete_endpoint = "/delete-item"
266delete_schema = "deleteItem"
267
268[identity]
269id_field = "name"
270import_field = "name"
271force_new_fields = ["name"]
272
273[fields]
274token = { skip = true }
275uid_token = { skip = true }
276json = { skip = true }
277delete_protection = { type_override = "bool" }
278"#;
279        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
280        assert_eq!(spec.resource.name, "akeyless_static_secret");
281        assert_eq!(spec.crud.create_endpoint, "/create-secret");
282        assert!(spec.fields.get("token").unwrap().skip);
283        assert_eq!(spec.identity.force_new_fields, vec!["name"]);
284    }
285
286    #[test]
287    fn parse_data_source_spec() {
288        let toml_str = r#"
289[data_source]
290name = "akeyless_auth_method"
291description = "Read an auth method"
292
293[read]
294endpoint = "/get-auth-method"
295schema = "GetAuthMethod"
296response_schema = "AuthMethod"
297
298[fields]
299token = { skip = true }
300
301[read_mapping]
302"auth_method_access_id" = "access_id"
303"#;
304        let spec: DataSourceSpec = toml::from_str(toml_str).expect("parse");
305        assert_eq!(spec.data_source.name, "akeyless_auth_method");
306        assert_eq!(spec.read.endpoint, "/get-auth-method");
307        assert_eq!(spec.read.schema, "GetAuthMethod");
308        assert_eq!(spec.read.response_schema, Some("AuthMethod".to_string()));
309        assert!(spec.fields.get("token").unwrap().skip);
310        assert_eq!(
311            spec.read_mapping.get("auth_method_access_id"),
312            Some(&"access_id".to_string())
313        );
314    }
315
316    #[test]
317    fn parse_provider_spec() {
318        let toml_str = r#"
319[provider]
320name = "akeyless"
321description = "Akeyless Vault Provider"
322version = "1.0.0"
323sdk_import = "github.com/akeylesslabs/akeyless-go/v5"
324
325[auth]
326token_field = "token"
327env_var = "AKEYLESS_ACCESS_TOKEN"
328gateway_url_field = "api_gateway_address"
329gateway_env_var = "AKEYLESS_GATEWAY"
330
331[defaults]
332skip_fields = ["token", "uid-token", "json"]
333"#;
334        let spec: ProviderSpec = toml::from_str(toml_str).expect("parse");
335        assert_eq!(spec.provider.name, "akeyless");
336        assert_eq!(spec.auth.token_field, "token");
337        assert_eq!(spec.defaults.skip_fields.len(), 3);
338    }
339
340    // --- ResourceSpec::load from file ---
341
342    #[test]
343    fn resource_spec_load_from_file() {
344        let dir = tempfile::tempdir().unwrap();
345        let path = dir.path().join("resource.toml");
346        std::fs::write(
347            &path,
348            r#"
349[resource]
350name = "test_res"
351description = "desc"
352category = "cat"
353
354[crud]
355create_endpoint = "/create"
356create_schema = "Create"
357read_endpoint = "/read"
358read_schema = "Read"
359delete_endpoint = "/delete"
360delete_schema = "Delete"
361
362[identity]
363id_field = "id"
364"#,
365        )
366        .unwrap();
367        let spec = ResourceSpec::load(&path).unwrap();
368        assert_eq!(spec.resource.name, "test_res");
369        assert_eq!(spec.identity.id_field, "id");
370    }
371
372    #[test]
373    fn resource_spec_load_nonexistent_file() {
374        let result = ResourceSpec::load(Path::new("/nonexistent/path.toml"));
375        assert!(result.is_err());
376    }
377
378    #[test]
379    fn resource_spec_load_invalid_toml() {
380        let dir = tempfile::tempdir().unwrap();
381        let path = dir.path().join("bad.toml");
382        std::fs::write(&path, "this is not valid toml {{{").unwrap();
383        let result = ResourceSpec::load(&path);
384        assert!(result.is_err());
385    }
386
387    // --- ProviderSpec::load from file ---
388
389    #[test]
390    fn provider_spec_load_from_file() {
391        let dir = tempfile::tempdir().unwrap();
392        let path = dir.path().join("provider.toml");
393        std::fs::write(
394            &path,
395            r#"
396[provider]
397name = "test"
398description = "Test Provider"
399version = "0.1.0"
400sdk_import = "github.com/test/sdk"
401
402[auth]
403token_field = "tok"
404env_var = "TOK_ENV"
405gateway_url_field = "gw"
406gateway_env_var = "GW_ENV"
407"#,
408        )
409        .unwrap();
410        let spec = ProviderSpec::load(&path).unwrap();
411        assert_eq!(spec.provider.name, "test");
412        assert_eq!(spec.auth.token_field, "tok");
413    }
414
415    #[test]
416    fn provider_spec_load_nonexistent_file() {
417        let result = ProviderSpec::load(Path::new("/nonexistent/provider.toml"));
418        assert!(result.is_err());
419    }
420
421    // --- DataSourceSpec::load from file ---
422
423    #[test]
424    fn datasource_spec_load_from_file() {
425        let dir = tempfile::tempdir().unwrap();
426        let path = dir.path().join("ds.toml");
427        std::fs::write(
428            &path,
429            r#"
430[data_source]
431name = "test_ds"
432description = "A data source"
433
434[read]
435endpoint = "/get"
436schema = "GetSchema"
437"#,
438        )
439        .unwrap();
440        let spec = DataSourceSpec::load(&path).unwrap();
441        assert_eq!(spec.data_source.name, "test_ds");
442        assert_eq!(spec.read.endpoint, "/get");
443        assert!(spec.read.response_schema.is_none());
444    }
445
446    #[test]
447    fn datasource_spec_load_nonexistent_file() {
448        let result = DataSourceSpec::load(Path::new("/nonexistent/ds.toml"));
449        assert!(result.is_err());
450    }
451
452    // --- Defaults / Optional fields ---
453
454    #[test]
455    fn resource_spec_optional_fields_default() {
456        let toml_str = r#"
457[resource]
458name = "minimal"
459
460[crud]
461create_endpoint = "/create"
462create_schema = "C"
463read_endpoint = "/read"
464read_schema = "R"
465delete_endpoint = "/delete"
466delete_schema = "D"
467
468[identity]
469id_field = "id"
470"#;
471        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
472        assert_eq!(spec.resource.description, "");
473        assert_eq!(spec.resource.category, "");
474        assert!(spec.crud.update_endpoint.is_none());
475        assert!(spec.crud.update_schema.is_none());
476        assert!(spec.crud.read_response_schema.is_none());
477        assert!(spec.identity.import_field.is_none());
478        assert!(spec.identity.force_new_fields.is_empty());
479        assert!(spec.fields.is_empty());
480        assert!(spec.read_mapping.is_empty());
481    }
482
483    #[test]
484    fn field_override_defaults() {
485        let fo = FieldOverride::default();
486        assert!(!fo.computed);
487        assert!(!fo.sensitive);
488        assert!(!fo.skip);
489        assert!(!fo.force_new);
490        assert!(fo.type_override.is_none());
491        assert!(fo.description.is_none());
492    }
493
494    #[test]
495    fn provider_defaults_empty() {
496        let pd = ProviderDefaults::default();
497        assert!(pd.skip_fields.is_empty());
498    }
499
500    #[test]
501    fn auth_config_defaults() {
502        let ac = AuthConfig::default();
503        assert_eq!(ac.token_field, "");
504        assert_eq!(ac.env_var, "");
505        assert_eq!(ac.gateway_url_field, "");
506        assert_eq!(ac.gateway_env_var, "");
507    }
508
509    // --- Serialization round-trip ---
510
511    #[test]
512    fn resource_spec_serialize_roundtrip() {
513        let toml_str = r#"
514[resource]
515name = "test_rt"
516description = "roundtrip"
517category = "cat"
518
519[crud]
520create_endpoint = "/c"
521create_schema = "C"
522read_endpoint = "/r"
523read_schema = "R"
524delete_endpoint = "/d"
525delete_schema = "D"
526
527[identity]
528id_field = "id"
529"#;
530        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
531        let serialized = toml::to_string(&spec).expect("serialize");
532        let reparsed: ResourceSpec = toml::from_str(&serialized).expect("reparse");
533        assert_eq!(reparsed.resource.name, "test_rt");
534        assert_eq!(reparsed.crud.create_endpoint, "/c");
535    }
536
537    #[test]
538    fn field_override_all_flags() {
539        let toml_str = r#"
540[resource]
541name = "test"
542
543[crud]
544create_endpoint = "/c"
545create_schema = "C"
546read_endpoint = "/r"
547read_schema = "R"
548delete_endpoint = "/d"
549delete_schema = "D"
550
551[identity]
552id_field = "id"
553
554[fields.secret_key]
555computed = true
556sensitive = true
557skip = false
558force_new = true
559type_override = "bool"
560description = "Custom desc"
561"#;
562        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
563        let fo = spec.fields.get("secret_key").unwrap();
564        assert!(fo.computed);
565        assert!(fo.sensitive);
566        assert!(!fo.skip);
567        assert!(fo.force_new);
568        assert_eq!(fo.type_override, Some("bool".to_string()));
569        assert_eq!(fo.description, Some("Custom desc".to_string()));
570    }
571
572    // --- ResourceSpec::validate tests ---
573
574    fn make_validation_api() -> openapi_forge::Spec {
575        let api_str = r#"
576openapi: "3.0.0"
577info: { title: Test, version: "1.0" }
578paths:
579  /create:
580    post:
581      operationId: create
582      requestBody:
583        content:
584          application/json:
585            schema:
586              $ref: '#/components/schemas/Create'
587      responses:
588        "200": { description: ok }
589  /read:
590    post: { operationId: read, responses: { "200": { description: ok } } }
591  /delete:
592    post: { operationId: delete, responses: { "200": { description: ok } } }
593components:
594  schemas:
595    Create:
596      type: object
597      properties:
598        name: { type: string }
599    Read:
600      type: object
601      properties:
602        name: { type: string }
603    Delete:
604      type: object
605      properties:
606        name: { type: string }
607    Update:
608      type: object
609      properties:
610        name: { type: string }
611    ResponseSchema:
612      type: object
613      properties:
614        output: { type: string }
615"#;
616        openapi_forge::Spec::parse(api_str).expect("parse api")
617    }
618
619    #[test]
620    fn validate_resource_spec_success() {
621        let toml_str = r#"
622[resource]
623name = "test"
624
625[crud]
626create_endpoint = "/create"
627create_schema = "Create"
628read_endpoint = "/read"
629read_schema = "Read"
630delete_endpoint = "/delete"
631delete_schema = "Delete"
632
633[identity]
634id_field = "name"
635"#;
636        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
637        let api = make_validation_api();
638        assert!(spec.validate(&api).is_ok());
639    }
640
641    #[test]
642    fn validate_resource_spec_missing_create_schema() {
643        let toml_str = r#"
644[resource]
645name = "test"
646
647[crud]
648create_endpoint = "/create"
649create_schema = "NonExistent"
650read_endpoint = "/read"
651read_schema = "Read"
652delete_endpoint = "/delete"
653delete_schema = "Delete"
654
655[identity]
656id_field = "name"
657"#;
658        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
659        let api = make_validation_api();
660        let err = spec.validate(&api).unwrap_err();
661        assert!(err.to_string().contains("NonExistent"));
662    }
663
664    #[test]
665    fn validate_resource_spec_missing_read_schema() {
666        let toml_str = r#"
667[resource]
668name = "test"
669
670[crud]
671create_endpoint = "/create"
672create_schema = "Create"
673read_endpoint = "/read"
674read_schema = "MissingRead"
675delete_endpoint = "/delete"
676delete_schema = "Delete"
677
678[identity]
679id_field = "name"
680"#;
681        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
682        let api = make_validation_api();
683        let err = spec.validate(&api).unwrap_err();
684        assert!(err.to_string().contains("MissingRead"));
685    }
686
687    #[test]
688    fn validate_resource_spec_missing_delete_schema() {
689        let toml_str = r#"
690[resource]
691name = "test"
692
693[crud]
694create_endpoint = "/create"
695create_schema = "Create"
696read_endpoint = "/read"
697read_schema = "Read"
698delete_endpoint = "/delete"
699delete_schema = "MissingDelete"
700
701[identity]
702id_field = "name"
703"#;
704        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
705        let api = make_validation_api();
706        let err = spec.validate(&api).unwrap_err();
707        assert!(err.to_string().contains("MissingDelete"));
708    }
709
710    #[test]
711    fn validate_resource_spec_missing_update_schema() {
712        let toml_str = r#"
713[resource]
714name = "test"
715
716[crud]
717create_endpoint = "/create"
718create_schema = "Create"
719update_endpoint = "/update"
720update_schema = "MissingUpdate"
721read_endpoint = "/read"
722read_schema = "Read"
723delete_endpoint = "/delete"
724delete_schema = "Delete"
725
726[identity]
727id_field = "name"
728"#;
729        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
730        let api = make_validation_api();
731        let err = spec.validate(&api).unwrap_err();
732        assert!(err.to_string().contains("MissingUpdate"));
733    }
734
735    #[test]
736    fn validate_resource_spec_missing_response_schema() {
737        let toml_str = r#"
738[resource]
739name = "test"
740
741[crud]
742create_endpoint = "/create"
743create_schema = "Create"
744read_endpoint = "/read"
745read_schema = "Read"
746read_response_schema = "MissingResponse"
747delete_endpoint = "/delete"
748delete_schema = "Delete"
749
750[identity]
751id_field = "name"
752"#;
753        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
754        let api = make_validation_api();
755        let err = spec.validate(&api).unwrap_err();
756        assert!(err.to_string().contains("MissingResponse"));
757    }
758
759    #[test]
760    fn validate_resource_spec_missing_endpoint() {
761        let toml_str = r#"
762[resource]
763name = "test_res"
764
765[crud]
766create_endpoint = "/nonexistent-endpoint"
767create_schema = "Create"
768read_endpoint = "/read"
769read_schema = "Read"
770delete_endpoint = "/delete"
771delete_schema = "Delete"
772
773[identity]
774id_field = "name"
775"#;
776        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
777        let api = make_validation_api();
778        let err = spec.validate(&api).unwrap_err();
779        let msg = err.to_string();
780        assert!(msg.contains("test_res"));
781        assert!(msg.contains("/nonexistent-endpoint"));
782    }
783
784    #[test]
785    fn validate_resource_spec_with_optional_schemas_success() {
786        let toml_str = r#"
787[resource]
788name = "test"
789
790[crud]
791create_endpoint = "/create"
792create_schema = "Create"
793update_endpoint = "/create"
794update_schema = "Update"
795read_endpoint = "/read"
796read_schema = "Read"
797read_response_schema = "ResponseSchema"
798delete_endpoint = "/delete"
799delete_schema = "Delete"
800
801[identity]
802id_field = "name"
803"#;
804        let spec: ResourceSpec = toml::from_str(toml_str).expect("parse");
805        let api = make_validation_api();
806        assert!(spec.validate(&api).is_ok());
807    }
808
809    // --- DataSourceSpec::validate tests ---
810
811    #[test]
812    fn validate_datasource_spec_success() {
813        let toml_str = r#"
814[data_source]
815name = "test_ds"
816description = "Test"
817
818[read]
819endpoint = "/read"
820schema = "Read"
821"#;
822        let spec: DataSourceSpec = toml::from_str(toml_str).expect("parse");
823        let api = make_validation_api();
824        assert!(spec.validate(&api).is_ok());
825    }
826
827    #[test]
828    fn validate_datasource_spec_missing_schema() {
829        let toml_str = r#"
830[data_source]
831name = "test_ds"
832description = "Test"
833
834[read]
835endpoint = "/read"
836schema = "MissingSchema"
837"#;
838        let spec: DataSourceSpec = toml::from_str(toml_str).expect("parse");
839        let api = make_validation_api();
840        let err = spec.validate(&api).unwrap_err();
841        assert!(err.to_string().contains("MissingSchema"));
842    }
843
844    #[test]
845    fn validate_datasource_spec_missing_response_schema() {
846        let toml_str = r#"
847[data_source]
848name = "test_ds"
849description = "Test"
850
851[read]
852endpoint = "/read"
853schema = "Read"
854response_schema = "MissingResp"
855"#;
856        let spec: DataSourceSpec = toml::from_str(toml_str).expect("parse");
857        let api = make_validation_api();
858        let err = spec.validate(&api).unwrap_err();
859        assert!(err.to_string().contains("MissingResp"));
860    }
861
862    #[test]
863    fn validate_datasource_spec_missing_endpoint() {
864        let toml_str = r#"
865[data_source]
866name = "test_ds"
867description = "Test"
868
869[read]
870endpoint = "/nonexistent"
871schema = "Read"
872"#;
873        let spec: DataSourceSpec = toml::from_str(toml_str).expect("parse");
874        let api = make_validation_api();
875        let err = spec.validate(&api).unwrap_err();
876        let msg = err.to_string();
877        assert!(msg.contains("test_ds"));
878        assert!(msg.contains("/nonexistent"));
879    }
880
881    #[test]
882    fn validate_datasource_spec_with_response_schema_success() {
883        let toml_str = r#"
884[data_source]
885name = "test_ds"
886description = "Test"
887
888[read]
889endpoint = "/read"
890schema = "Read"
891response_schema = "ResponseSchema"
892"#;
893        let spec: DataSourceSpec = toml::from_str(toml_str).expect("parse");
894        let api = make_validation_api();
895        assert!(spec.validate(&api).is_ok());
896    }
897
898    // --- ProviderSpec::load invalid TOML ---
899
900    #[test]
901    fn provider_spec_load_invalid_toml() {
902        let dir = tempfile::tempdir().unwrap();
903        let path = dir.path().join("bad_provider.toml");
904        std::fs::write(&path, "this is not valid toml {{{").unwrap();
905        let result = ProviderSpec::load(&path);
906        assert!(result.is_err());
907    }
908
909    // --- DataSourceSpec::load invalid TOML ---
910
911    #[test]
912    fn datasource_spec_load_invalid_toml() {
913        let dir = tempfile::tempdir().unwrap();
914        let path = dir.path().join("bad_ds.toml");
915        std::fs::write(&path, "this is not valid toml {{{").unwrap();
916        let result = DataSourceSpec::load(&path);
917        assert!(result.is_err());
918    }
919}