1pub mod claims;
102pub mod error;
103#[cfg(target_arch = "wasm32")]
104pub mod host;
105mod lifecycle;
106mod literal_json;
107pub mod model;
108pub mod native;
109pub mod prelude;
110pub mod protocol;
111pub mod source;
112pub mod traits;
113pub mod types;
114
115pub use error::{ExtensionError, Result};
117#[doc(hidden)]
118pub use lifecycle::ProtocolSession as __ProtocolSession;
119pub use native::{NativeBackend, NativeExtension, NativeFrontend, NativeProtocol, NativeWorkspace};
120pub use source::{SourceContextError, SourcePath, SourceRoot};
121pub use traits::{Backend, Extension, Frontend, Transform, Validator, Workspace};
122pub use types::*;
123
124#[macro_export]
130macro_rules! export_extension {
131 ($impl:ty, $($capability:ident),+ $(,)?) => {
132 #[cfg(target_arch = "wasm32")]
133 use $crate::extism_pdk as extism_pdk;
134 #[cfg(target_arch = "wasm32")]
135 use extism_pdk::*;
136
137 #[cfg(target_arch = "wasm32")]
139 #[plugin_fn]
140 pub fn morphir_extension_info() -> FnResult<Json<$crate::ExtensionInfo>> {
141 let mut declared_types = Vec::new();
142 $crate::__push_extension_types!(declared_types, $($capability),+);
143 Ok(Json($crate::__extension_info::<$impl>(&declared_types)))
144 }
145
146 #[cfg(target_arch = "wasm32")]
148 #[plugin_fn]
149 pub fn morphir_extension_capabilities() -> FnResult<Json<$crate::ExtensionCapabilities>> {
150 Ok(Json(<$impl as $crate::Extension>::capabilities()))
151 }
152
153 #[cfg(target_arch = "wasm32")]
155 #[plugin_fn]
156 pub fn handle(
157 Json(request): Json<$crate::protocol::ExtensionRequest>,
158 ) -> FnResult<Json<$crate::protocol::ExtensionResponse>> {
159 static SESSION: $crate::__ProtocolSession = $crate::__ProtocolSession::new();
160 let mut dispatchers: Vec<$crate::DispatchFn<$impl>> = Vec::new();
161 let mut declared_types = Vec::new();
162 $crate::__push_extension_dispatchers!(dispatchers, $impl, $($capability),+);
163 $crate::__push_extension_types!(declared_types, $($capability),+);
164 let result = SESSION.dispatch(&request, || $crate::__dispatch_request::<$impl>(
165 &request,
166 &dispatchers,
167 &declared_types,
168 ));
169 Ok(Json(result))
170 }
171 };
172}
173
174#[doc(hidden)]
176#[macro_export]
177macro_rules! __push_extension_types {
178 ($types:ident, backend $(, $remaining:ident)*) => {
179 $types.push($crate::ExtensionType::Backend);
180 $crate::__push_extension_types!($types $(, $remaining)*);
181 };
182 ($types:ident, frontend $(, $remaining:ident)*) => {
183 $types.push($crate::ExtensionType::Frontend);
184 $crate::__push_extension_types!($types $(, $remaining)*);
185 };
186 ($types:ident, validator $(, $remaining:ident)*) => {
187 $types.push($crate::ExtensionType::Validator);
188 $crate::__push_extension_types!($types $(, $remaining)*);
189 };
190 ($types:ident, transform $(, $remaining:ident)*) => {
191 $types.push($crate::ExtensionType::Transform);
192 $crate::__push_extension_types!($types $(, $remaining)*);
193 };
194 ($types:ident, workspace $(, $remaining:ident)*) => {
195 $types.push($crate::ExtensionType::Workspace);
196 $crate::__push_extension_types!($types $(, $remaining)*);
197 };
198 ($types:ident) => {};
199}
200
201#[doc(hidden)]
203#[macro_export]
204macro_rules! __push_extension_dispatchers {
205 ($dispatchers:ident, $impl:ty, backend $(, $remaining:ident)*) => {
206 $dispatchers.push($crate::__dispatch_backend::<$impl>);
207 $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
208 };
209 ($dispatchers:ident, $impl:ty, frontend $(, $remaining:ident)*) => {
210 $dispatchers.push($crate::__dispatch_frontend::<$impl>);
211 $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
212 };
213 ($dispatchers:ident, $impl:ty, validator $(, $remaining:ident)*) => {
214 $dispatchers.push($crate::__dispatch_validator::<$impl>);
215 $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
216 };
217 ($dispatchers:ident, $impl:ty, transform $(, $remaining:ident)*) => {
218 $dispatchers.push($crate::__dispatch_transform::<$impl>);
219 $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
220 };
221 ($dispatchers:ident, $impl:ty, workspace $(, $remaining:ident)*) => {
222 $dispatchers.push($crate::__dispatch_workspace::<$impl>);
223 $crate::__push_extension_dispatchers!($dispatchers, $impl $(, $remaining)*);
224 };
225 ($dispatchers:ident, $impl:ty) => {};
226}
227
228#[cfg(not(target_arch = "wasm32"))]
230#[macro_export]
231macro_rules! host_debug {
232 ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
233}
234
235#[cfg(not(target_arch = "wasm32"))]
236#[macro_export]
237macro_rules! host_info {
238 ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
239}
240
241#[cfg(not(target_arch = "wasm32"))]
242#[macro_export]
243macro_rules! host_warn {
244 ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
245}
246
247#[cfg(not(target_arch = "wasm32"))]
248#[macro_export]
249macro_rules! host_error {
250 ($($arg:tt)*) => {{ let _ = format_args!($($arg)*); }};
251}
252
253#[doc(hidden)]
255pub type DispatchFn<E> = fn(
256 &E,
257 &protocol::ExtensionRequest,
258) -> Option<std::result::Result<serde_json::Value, ExtensionError>>;
259
260pub(crate) type NativeRoleDispatch = std::sync::Arc<
267 dyn Fn(
268 &protocol::ExtensionRequest,
269 ) -> Option<std::result::Result<serde_json::Value, ExtensionError>>
270 + Send
271 + Sync,
272>;
273
274pub(crate) fn erase_dispatch<E>(
276 extension: std::sync::Arc<E>,
277 dispatch: DispatchFn<E>,
278) -> NativeRoleDispatch
279where
280 E: Send + Sync + 'static,
281{
282 std::sync::Arc::new(move |request| dispatch(extension.as_ref(), request))
283}
284
285#[doc(hidden)]
287pub fn __extension_info<E: Extension>(declared_types: &[ExtensionType]) -> ExtensionInfo {
288 let mut info = E::info();
289 info.types = declared_types.to_vec();
290 info
291}
292
293#[doc(hidden)]
299pub fn __dispatch_request<E: Extension + Default>(
300 request: &protocol::ExtensionRequest,
301 dispatchers: &[DispatchFn<E>],
302 declared_types: &[ExtensionType],
303) -> protocol::ExtensionResponse {
304 use protocol::methods;
305
306 match request.method.as_str() {
307 methods::DESCRIBE => dispatch_response(
308 &request.id,
309 dispatch_describe_with_metadata(
310 request,
311 &__extension_info::<E>(declared_types),
312 &E::capabilities(),
313 ),
314 ),
315 methods::INITIALIZE => dispatch_response(
316 &request.id,
317 dispatch_initialize::<E>(request, declared_types),
318 ),
319 methods::PING => dispatch_response(&request.id, Ok(serde_json::json!({ "ok": true }))),
320 methods::INFO => dispatch_response(
321 &request.id,
322 serde_json::to_value(__extension_info::<E>(declared_types))
323 .map_err(ExtensionError::from),
324 ),
325 methods::CAPABILITIES => dispatch_response(
326 &request.id,
327 serde_json::to_value(E::capabilities()).map_err(ExtensionError::from),
328 ),
329 methods::SHUTDOWN => dispatch_response(&request.id, Ok(serde_json::json!({}))),
330 _ => __dispatch_request_with(&E::default(), request, dispatchers, declared_types),
331 }
332}
333
334#[doc(hidden)]
340pub fn __dispatch_request_with<E: Extension>(
341 extension: &E,
342 request: &protocol::ExtensionRequest,
343 dispatchers: &[DispatchFn<E>],
344 declared_types: &[ExtensionType],
345) -> protocol::ExtensionResponse {
346 use protocol::methods;
347
348 match request.method.as_str() {
349 methods::DESCRIBE => dispatch_response(
350 &request.id,
351 dispatch_describe_with_metadata(
352 request,
353 &__extension_info::<E>(declared_types),
354 &E::capabilities(),
355 ),
356 ),
357 methods::INITIALIZE => {
358 let info = __extension_info::<E>(declared_types);
359 let capabilities = E::capabilities();
360 dispatch_response(
361 &request.id,
362 dispatch_initialize_with_metadata(request, &info, &capabilities),
363 )
364 }
365 methods::PING => dispatch_response(&request.id, Ok(serde_json::json!({ "ok": true }))),
366 methods::INFO => dispatch_response(
367 &request.id,
368 serde_json::to_value(__extension_info::<E>(declared_types))
369 .map_err(ExtensionError::from),
370 ),
371 methods::CAPABILITIES => dispatch_response(
372 &request.id,
373 serde_json::to_value(E::capabilities()).map_err(ExtensionError::from),
374 ),
375 methods::SHUTDOWN => dispatch_response(&request.id, Ok(serde_json::json!({}))),
376 _ => dispatch_capability_response(extension, request, dispatchers),
377 }
378}
379
380fn dispatch_role_response(
381 request: &protocol::ExtensionRequest,
382 dispatchers: &[NativeRoleDispatch],
383) -> protocol::ExtensionResponse {
384 for dispatch in dispatchers {
385 if let Some(result) = dispatch(request) {
386 return dispatch_response(&request.id, result);
387 }
388 }
389 protocol::ExtensionResponse::error_with_id(
390 request.id.clone(),
391 protocol::RpcError::method_not_found(&request.method),
392 )
393}
394
395pub(crate) fn dispatch_request_with_roles(
396 request: &protocol::ExtensionRequest,
397 dispatchers: &[NativeRoleDispatch],
398 info: &ExtensionInfo,
399 capabilities: &ExtensionCapabilities,
400) -> protocol::ExtensionResponse {
401 use protocol::methods;
402
403 let result = match request.method.as_str() {
404 methods::DESCRIBE => dispatch_describe_with_metadata(request, info, capabilities),
405 methods::INITIALIZE => dispatch_initialize_with_metadata(request, info, capabilities),
406 methods::PING => Ok(serde_json::json!({ "ok": true })),
407 methods::INFO => serde_json::to_value(info).map_err(ExtensionError::from),
408 methods::CAPABILITIES => serde_json::to_value(capabilities).map_err(ExtensionError::from),
409 methods::SHUTDOWN => Ok(serde_json::json!({})),
410 _ => return dispatch_role_response(request, dispatchers),
411 };
412
413 dispatch_response(&request.id, result)
414}
415
416fn dispatch_capability_response<E>(
417 extension: &E,
418 request: &protocol::ExtensionRequest,
419 dispatchers: &[DispatchFn<E>],
420) -> protocol::ExtensionResponse {
421 match dispatch_capability_request(extension, request, dispatchers) {
422 Some(result) => dispatch_response(&request.id, result),
423 None => protocol::ExtensionResponse::error_with_id(
424 request.id.clone(),
425 protocol::RpcError::method_not_found(&request.method),
426 ),
427 }
428}
429
430fn dispatch_capability_request<E>(
431 extension: &E,
432 request: &protocol::ExtensionRequest,
433 dispatchers: &[DispatchFn<E>],
434) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
435 dispatchers
436 .iter()
437 .find_map(|dispatch| dispatch(extension, request))
438}
439
440fn dispatch_response(
441 request_id: &protocol::RequestId,
442 result: std::result::Result<serde_json::Value, ExtensionError>,
443) -> protocol::ExtensionResponse {
444 match result {
445 Ok(value) => protocol::ExtensionResponse {
446 jsonrpc: "2.0".to_string(),
447 result: Some(value),
448 error: None,
449 id: request_id.clone(),
450 },
451 Err(error) => {
452 protocol::ExtensionResponse::from_extension_error_with_id(request_id.clone(), &error)
453 }
454 }
455}
456
457fn dispatch_describe_with_metadata(
458 request: &protocol::ExtensionRequest,
459 info: &ExtensionInfo,
460 capabilities: &ExtensionCapabilities,
461) -> std::result::Result<serde_json::Value, ExtensionError> {
462 let params: protocol::DescribeParams = serde_json::from_value(request.params.clone())
463 .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
464 let implemented = model::guest::versions(capabilities);
465 if !params
466 .protocol_versions
467 .iter()
468 .any(|version| implemented.contains(version))
469 {
470 return Err(ExtensionError::ProtocolVersionMismatch {
471 host_versions: params.protocol_versions,
472 extension_versions: implemented,
473 });
474 }
475 let claims =
476 claims::CapabilityClaimSet::from_metadata(implemented, info.clone(), capabilities)?;
477 serde_json::to_value(claims).map_err(ExtensionError::from)
478}
479
480fn dispatch_initialize<E: Extension>(
481 request: &protocol::ExtensionRequest,
482 declared_types: &[ExtensionType],
483) -> std::result::Result<serde_json::Value, ExtensionError> {
484 let info = __extension_info::<E>(declared_types);
485 let capabilities = E::capabilities();
486 dispatch_initialize_with_metadata(request, &info, &capabilities)
487}
488
489fn dispatch_initialize_with_metadata(
490 request: &protocol::ExtensionRequest,
491 info: &ExtensionInfo,
492 capabilities: &ExtensionCapabilities,
493) -> std::result::Result<serde_json::Value, ExtensionError> {
494 let params: protocol::InitializeParams = serde_json::from_value(request.params.clone())
495 .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
496 serde_json::to_value(model::guest::initialize(¶ms, info, capabilities)?)
497 .map_err(ExtensionError::from)
498}
499
500#[doc(hidden)]
501pub fn __dispatch_frontend<E: Frontend>(
502 extension: &E,
503 request: &protocol::ExtensionRequest,
504) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
505 match request.method.as_str() {
506 protocol::methods::COMPILE => Some((|| {
507 let params: types::CompileRequest = serde_json::from_value(request.params.clone())
508 .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
509 serde_json::to_value(extension.compile(params)?).map_err(ExtensionError::from)
510 })()),
511 protocol::methods::COMPILE_MODEL => Some((|| {
512 let params: model::CompileModelRequest = serde_json::from_value(request.params.clone())
513 .map_err(|_| {
514 ExtensionError::InvalidParams("Invalid model compilation request".into())
515 })?;
516 serde_json::to_value(extension.compile_model(params)?).map_err(ExtensionError::from)
517 })()),
518 _ => None,
519 }
520}
521
522#[doc(hidden)]
523pub fn __dispatch_backend<E: Backend>(
524 extension: &E,
525 request: &protocol::ExtensionRequest,
526) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
527 match request.method.as_str() {
528 protocol::methods::GENERATE => Some((|| {
529 let params: types::GenerateRequest = serde_json::from_value(request.params.clone())
530 .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
531 serde_json::to_value(extension.generate(params)?).map_err(ExtensionError::from)
532 })()),
533 protocol::methods::GENERATE_MODEL => Some((|| {
534 let params: model::GenerateModelRequest =
535 serde_json::from_value(request.params.clone()).map_err(|_| {
536 ExtensionError::InvalidParams("Invalid model generation request".into())
537 })?;
538 serde_json::to_value(extension.generate_model(params)?).map_err(ExtensionError::from)
539 })()),
540 _ => None,
541 }
542}
543
544#[doc(hidden)]
545pub fn __dispatch_validator<E: Validator>(
546 extension: &E,
547 request: &protocol::ExtensionRequest,
548) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
549 (request.method == protocol::methods::VALIDATE).then(|| {
550 let params: types::ValidateRequest = serde_json::from_value(request.params.clone())
551 .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
552 serde_json::to_value(extension.validate(params)?).map_err(ExtensionError::from)
553 })
554}
555
556#[doc(hidden)]
557pub fn __dispatch_transform<E: Transform>(
558 extension: &E,
559 request: &protocol::ExtensionRequest,
560) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
561 (request.method == protocol::methods::TRANSFORM).then(|| {
562 let params: types::TransformRequest = serde_json::from_value(request.params.clone())
563 .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
564 serde_json::to_value(extension.transform(params)?).map_err(ExtensionError::from)
565 })
566}
567
568#[doc(hidden)]
569pub fn __dispatch_workspace<E: Workspace>(
570 extension: &E,
571 request: &protocol::ExtensionRequest,
572) -> Option<std::result::Result<serde_json::Value, ExtensionError>> {
573 (request.method == protocol::methods::WORKSPACE_DISCOVER).then(|| {
574 let params: morphir_workspace::DiscoveryRequest =
575 serde_json::from_value(request.params.clone())
576 .map_err(|error| ExtensionError::InvalidParams(error.to_string()))?;
577 serde_json::to_value(extension.discover(params)?).map_err(ExtensionError::from)
578 })
579}
580
581#[doc(hidden)]
583#[cfg(target_arch = "wasm32")]
584pub use extism_pdk;
585
586#[cfg(test)]
587mod tests {
588 use super::*;
589 use crate::protocol::{ExtensionRequest, methods};
590 use morphir_workspace::{
591 DiscoveryRequest, DiscoveryResponse, FileEntry, FileTree, RelativePath,
592 };
593 use std::collections::BTreeMap;
594 use std::sync::atomic::{AtomicUsize, Ordering};
595
596 static LAZY_DEFAULT_CONSTRUCTIONS: AtomicUsize = AtomicUsize::new(0);
597 static LAZY_METADATA_INFO_CALLS: AtomicUsize = AtomicUsize::new(0);
598 static LAZY_METADATA_CAPABILITY_CALLS: AtomicUsize = AtomicUsize::new(0);
599
600 struct LazyDefaultExtension;
601
602 impl Default for LazyDefaultExtension {
603 fn default() -> Self {
604 LAZY_DEFAULT_CONSTRUCTIONS.fetch_add(1, Ordering::SeqCst);
605 Self
606 }
607 }
608
609 impl Extension for LazyDefaultExtension {
610 fn info() -> ExtensionInfo {
611 ExtensionInfo::default()
612 }
613 }
614
615 #[derive(Default)]
616 struct MetadataLazyExtension;
617
618 impl Extension for MetadataLazyExtension {
619 fn info() -> ExtensionInfo {
620 LAZY_METADATA_INFO_CALLS.fetch_add(1, Ordering::SeqCst);
621 ExtensionInfo::default()
622 }
623
624 fn capabilities() -> ExtensionCapabilities {
625 LAZY_METADATA_CAPABILITY_CALLS.fetch_add(1, Ordering::SeqCst);
626 ExtensionCapabilities::default()
627 }
628 }
629
630 #[derive(Default)]
631 struct RecordingBackend;
632
633 impl Extension for RecordingBackend {
634 fn info() -> ExtensionInfo {
635 ExtensionInfo {
636 id: "recording-backend".into(),
637 name: "Recording backend".into(),
638 types: vec![],
639 ..ExtensionInfo::default()
640 }
641 }
642 }
643
644 impl Backend for RecordingBackend {
645 fn generate(&self, request: GenerateRequest) -> Result<GenerateResult> {
646 Ok(GenerateResult {
647 success: true,
648 artifacts: vec![Artifact {
649 path: "observed.json".into(),
650 content: request.ir.to_string(),
651 binary: false,
652 }],
653 diagnostics: vec![],
654 })
655 }
656
657 fn target_languages() -> Vec<String> {
658 vec!["recording".into()]
659 }
660 }
661
662 #[derive(Default)]
663 struct RecordingWorkspace;
664
665 impl Extension for RecordingWorkspace {
666 fn info() -> ExtensionInfo {
667 ExtensionInfo {
668 id: "recording-workspace".into(),
669 name: "Recording workspace".into(),
670 version: "1.0.0".into(),
671 types: vec![],
672 ..ExtensionInfo::default()
673 }
674 }
675
676 fn capabilities() -> ExtensionCapabilities {
677 ExtensionCapabilities {
678 workspace: Some(WorkspaceCapability {
679 protocol_versions: vec![morphir_workspace::workspace_discovery_protocol()],
680 discover: true,
681 }),
682 ..ExtensionCapabilities::default()
683 }
684 }
685 }
686
687 impl Workspace for RecordingWorkspace {
688 fn discover(&self, request: DiscoveryRequest) -> Result<DiscoveryResponse> {
689 Ok(morphir_workspace::discover(request))
690 }
691 }
692
693 fn a_workspace_request() -> DiscoveryRequest {
694 DiscoveryRequest {
695 protocol_version: morphir_workspace::workspace_discovery_protocol(),
696 development_root: FileTree {
697 entries: BTreeMap::from([
698 (RelativePath::root(), FileEntry::Directory),
699 (
700 RelativePath::parse("morphir.toml").unwrap(),
701 FileEntry::File {
702 text: "[project]\nname = \"acme/orders\"\n".into(),
703 },
704 ),
705 ]),
706 },
707 morphir_home: None,
708 system_config: None,
709 environment: BTreeMap::new(),
710 cli_overlay: serde_json::json!({}),
711 purpose: Default::default(),
712 }
713 }
714
715 fn a_generate_request() -> ExtensionRequest {
716 ExtensionRequest::new(
717 methods::GENERATE,
718 GenerateRequest {
719 ir: serde_json::json!({ "observed": true }),
720 target: "recording".into(),
721 options: Default::default(),
722 },
723 7,
724 )
725 .expect("the request fixture should serialize")
726 }
727
728 fn an_initialize_request(protocol_versions: Vec<&str>) -> ExtensionRequest {
729 ExtensionRequest::new(
730 methods::INITIALIZE,
731 protocol::InitializeParams {
732 model_transport: None,
733 protocol_versions: protocol_versions.into_iter().map(str::to_string).collect(),
734 host: protocol::PeerInfo {
735 kind: Default::default(),
736 name: "conformance-host".into(),
737 version: "0.1.0".into(),
738 },
739 },
740 1,
741 )
742 .expect("the initialization fixture should serialize")
743 }
744
745 #[test]
746 fn control_requests_do_not_construct_default_extensions() {
747 LAZY_DEFAULT_CONSTRUCTIONS.store(0, Ordering::SeqCst);
748 let control_requests = [
749 ExtensionRequest::new(methods::PING, serde_json::json!({}), 1).unwrap(),
750 ExtensionRequest::new(methods::INFO, serde_json::json!({}), 2).unwrap(),
751 ExtensionRequest::new(methods::CAPABILITIES, serde_json::json!({}), 3).unwrap(),
752 an_initialize_request(vec![protocol::MEP_VERSION]),
753 ExtensionRequest::new(methods::SHUTDOWN, serde_json::json!({}), 5).unwrap(),
754 ];
755
756 for request in control_requests {
757 let response = __dispatch_request::<LazyDefaultExtension>(&request, &[], &[]);
758 assert!(response.error.is_none());
759 }
760 assert_eq!(LAZY_DEFAULT_CONSTRUCTIONS.load(Ordering::SeqCst), 0);
761
762 let request =
763 ExtensionRequest::new("test.extension.method", serde_json::json!({}), 6).unwrap();
764 let _ = __dispatch_request::<LazyDefaultExtension>(&request, &[], &[]);
765 assert_eq!(LAZY_DEFAULT_CONSTRUCTIONS.load(Ordering::SeqCst), 1);
766 }
767
768 #[test]
769 fn extension_method_dispatch_does_not_refresh_static_metadata() {
770 LAZY_METADATA_INFO_CALLS.store(0, Ordering::SeqCst);
771 LAZY_METADATA_CAPABILITY_CALLS.store(0, Ordering::SeqCst);
772 let request =
773 ExtensionRequest::new("test.extension.method", serde_json::json!({}), 1).unwrap();
774
775 let _ = __dispatch_request::<MetadataLazyExtension>(&request, &[], &[]);
776
777 assert_eq!(LAZY_METADATA_INFO_CALLS.load(Ordering::SeqCst), 0);
778 assert_eq!(LAZY_METADATA_CAPABILITY_CALLS.load(Ordering::SeqCst), 0);
779 }
780
781 #[test]
782 fn backend_requests_reach_the_backend_implementation() {
783 let response = __dispatch_request::<RecordingBackend>(
784 &a_generate_request(),
785 &[__dispatch_backend::<RecordingBackend>],
786 &[ExtensionType::Backend],
787 );
788 let result: GenerateResult = serde_json::from_value(
789 response
790 .result
791 .expect("backend dispatch should return a successful result"),
792 )
793 .expect("backend dispatch should return a GenerateResult");
794
795 assert!(result.success);
796 assert_eq!(result.artifacts.len(), 1);
797 assert_eq!(result.artifacts[0].path, "observed.json");
798 assert_eq!(result.artifacts[0].content, r#"{"observed":true}"#);
799 assert!(result.diagnostics.is_empty());
800 }
801
802 #[test]
803 fn workspace_requests_reach_the_workspace_implementation() {
804 let response = __dispatch_request::<RecordingWorkspace>(
805 &ExtensionRequest::new(methods::WORKSPACE_DISCOVER, a_workspace_request(), 8)
806 .expect("the workspace request should serialize"),
807 &[__dispatch_workspace::<RecordingWorkspace>],
808 &[ExtensionType::Workspace],
809 );
810 let result: DiscoveryResponse = serde_json::from_value(
811 response
812 .result
813 .expect("workspace dispatch should return a discovery response"),
814 )
815 .expect("workspace dispatch should return a typed response");
816
817 let snapshot = result
818 .into_result()
819 .expect("the workspace fixture should discover");
820 assert_eq!(snapshot.projects[0].name, "acme/orders");
821 }
822
823 #[test]
824 fn malformed_workspace_parameters_are_invalid_params() {
825 let request = ExtensionRequest::new(
826 methods::WORKSPACE_DISCOVER,
827 serde_json::json!({ "protocolVersion": "one" }),
828 9,
829 )
830 .expect("the malformed request should still be valid JSON-RPC");
831 let response = __dispatch_request::<RecordingWorkspace>(
832 &request,
833 &[__dispatch_workspace::<RecordingWorkspace>],
834 &[ExtensionType::Workspace],
835 );
836
837 assert_eq!(
838 response
839 .error
840 .expect("workspace parameters should fail")
841 .code,
842 protocol::error_codes::INVALID_PARAMS
843 );
844 }
845
846 #[test]
847 fn initialization_reports_the_workspace_contract() {
848 let response = __dispatch_request::<RecordingWorkspace>(
849 &an_initialize_request(vec!["0.1"]),
850 &[__dispatch_workspace::<RecordingWorkspace>],
851 &[ExtensionType::Workspace],
852 );
853 let result: protocol::InitializeResult =
854 serde_json::from_value(response.result.expect("workspace peers should initialize"))
855 .expect("initialization should return the negotiated session");
856
857 assert_eq!(result.extension.types, vec![ExtensionType::Workspace]);
858 assert_eq!(
859 result.capabilities.workspace,
860 Some(WorkspaceCapability {
861 protocol_versions: vec![morphir_workspace::workspace_discovery_protocol()],
862 discover: true,
863 })
864 );
865 }
866
867 #[test]
868 fn initialization_negotiates_mep_0_1_and_reports_the_extension() {
869 let response = __dispatch_request::<RecordingBackend>(
870 &an_initialize_request(vec!["0.1"]),
871 &[__dispatch_backend::<RecordingBackend>],
872 &[ExtensionType::Backend],
873 );
874 let result: protocol::InitializeResult =
875 serde_json::from_value(response.result.expect("compatible peers should initialize"))
876 .expect("initialization should return the negotiated session");
877
878 assert_eq!(result.protocol_version, protocol::MEP_VERSION);
879 assert_eq!(result.extension.id, "recording-backend");
880 assert_eq!(result.extension.types, vec![ExtensionType::Backend]);
881 }
882
883 #[test]
884 fn initialization_rejects_incompatible_protocol_versions() {
885 let response = __dispatch_request::<RecordingBackend>(
886 &an_initialize_request(vec!["9.0"]),
887 &[__dispatch_backend::<RecordingBackend>],
888 &[ExtensionType::Backend],
889 );
890
891 assert!(response.result.is_none());
892 assert_eq!(
893 response.error.expect("initialization should fail").code,
894 protocol::error_codes::PROTOCOL_VERSION_MISMATCH
895 );
896 }
897
898 #[test]
899 fn malformed_method_parameters_are_invalid_params() {
900 let request = ExtensionRequest::new(methods::GENERATE, serde_json::json!({}), 9)
901 .expect("the malformed request should still be valid JSON-RPC");
902 let response = __dispatch_request::<RecordingBackend>(
903 &request,
904 &[__dispatch_backend::<RecordingBackend>],
905 &[ExtensionType::Backend],
906 );
907
908 assert_eq!(
909 response.error.expect("method parameters should fail").code,
910 protocol::error_codes::INVALID_PARAMS
911 );
912 }
913}