1use std::collections::BTreeMap;
2use std::path::Path;
3
4use serde::{Deserialize, Serialize};
5
6use crate::error::ForgeError;
7
8#[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#[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#[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#[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#[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#[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#[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#[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#[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 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 pub fn validate(&self, api: &openapi_forge::Spec) -> Result<(), ForgeError> {
135 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 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 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#[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#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
193pub struct DataSourceMeta {
194 pub name: String,
195 #[serde(default)]
196 pub description: String,
197}
198
199#[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 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 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 #[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 #[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 #[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 #[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 #[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 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 #[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 #[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 #[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}