14426917358

Committed 13 Apr 2025 06:26AM UTC coverage: 77.858% (+0.3%) from 77.554%

Build # 14426917358

Build Type

Pull #221

github

Committed by

web-flow

Commit Message

Merge 68ad2d613 into 57594d285

Pull Request Pull Request #221: Hello world

Run Details

134 of 137 new or added lines in 2 files covered. (97.81%)

1 existing line in 1 file now uncovered.

4195 of 5388 relevant lines covered (77.86%)

1749.79 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.0

/lambda/src/memory_byte_sink_tests.rs

use crate::{
    builtins::{BUILTINS_NAMESPACE, LAMBDA_APPLY_METHOD_NAME},
    expressions::{
        evaluate, Expression, LambdaExpression, Object, Pointer, ReadLiteral, ReadVariable,
    },
    types::{Interface, Name, NamespaceId, Signature, Type, TypedExpression},
};
use astraea::{
    storage::{store_object, InMemoryValueStorage, LoadValue, StoreError, StoreValue},
    tree::{BlobDigest, HashedValue, Value, ValueBlob},
};
use async_trait::async_trait;
use std::{collections::BTreeMap, pin::Pin, sync::Arc};

#[derive(Debug)]
struct MemoryByteSink {
    pub self_interface: BlobDigest,
    pub written: Vec<Arc<Value>>,
}

impl MemoryByteSink {
    pub fn write_method_name() -> Name {
        let namespace = NamespaceId([42; 16]);
        Name::new(namespace, "write".to_string())
    }

    pub async fn deserialize(
        serialized: &Value,
        storage: &(dyn LoadValue + Sync),
    ) -> Option<MemoryByteSink> {
        if serialized.blob().len() > 0 {
            return None;
        }
        let mut references_iterator = serialized.references().iter();
        let self_interface = references_iterator.next()?;
        let mut written: Vec<Arc<Value>> = Vec::new();
        written.reserve(references_iterator.len());
        for reference in references_iterator {
            let value = storage.load_value(reference).await?;
            written.push(value.hash()?.value().clone());
        }
        Some(MemoryByteSink {
            self_interface: *self_interface,
            written,
        })
    }
}

#[async_trait]
impl Object for MemoryByteSink {
    async fn call_method(
        &self,
        interface: &BlobDigest,
        method: &Name,
        argument: &Pointer,
        _storage: &(dyn LoadValue + Sync),
        _read_variable: &Arc<ReadVariable>,
        _read_literal: &ReadLiteral,
    ) -> std::result::Result<Pointer, ()> {
        if &self.self_interface == interface {
            if &Self::write_method_name() == method {
                let argument_value = match argument.serialize_to_flat_value().await {
                    Some(success) => success,
                    None => todo!(),
                };
                let mut new_written = self.written.clone();
                new_written.push(argument_value);
                Ok(Pointer::Object(Arc::new(MemoryByteSink {
                    self_interface: self.self_interface,
                    written: new_written,
                })))
            } else {
                todo!()
            }
        } else {
            todo!()
        }
    }

    async fn serialize(
        &self,
        storage: &(dyn StoreValue + Sync),
    ) -> std::result::Result<HashedValue, StoreError> {
        let mut references = Vec::new();
        references.push(self.self_interface);
        for value in &self.written {
            references.push(
                storage
                    .store_value(&HashedValue::from(value.clone()))
                    .await?,
            );
        }
        Ok(HashedValue::from(Arc::new(Value::new(
            ValueBlob::empty(),
            references,
        ))))
    }

    async fn serialize_to_flat_value(&self) -> Option<Arc<Value>> {
        todo!()
    }
}

#[tokio::test]
async fn memory_byte_sink() {
    let storage = Arc::new(InMemoryValueStorage::empty());
    let namespace = NamespaceId([42; 16]);
    let memory_byte_sink_name = Name::new(namespace, "MemoryByteSink".to_string());
    let memory_byte_sink_type = Type::Named(memory_byte_sink_name);
    let lambda_parameter_name = Name::new(namespace.clone(), "output".to_string());
    let read_lambda_parameter_expression = TypedExpression::new(
        Expression::ReadVariable(lambda_parameter_name.clone()),
        memory_byte_sink_type.clone(),
    );
    let small_blob_name = Name::new(namespace, "SmallBlob".to_string());
    let small_blob_type = Type::Named(small_blob_name);
    let memory_byte_sink_interface = Arc::new(Interface::new(BTreeMap::from([(
        MemoryByteSink::write_method_name(),
        Signature::new(small_blob_type.clone(), memory_byte_sink_type.clone()),
    )])));
    let memory_byte_sink_interface_ref = store_object(&*storage, &*memory_byte_sink_interface)
        .await
        .unwrap();
    let hello_world_string = Arc::new(Value::from_string("Hello, world!\n").unwrap());
    let write_expression = read_lambda_parameter_expression
        .apply(
            &memory_byte_sink_interface,
            &memory_byte_sink_interface_ref,
            MemoryByteSink::write_method_name(),
            TypedExpression::new(
                Expression::Literal(
                    small_blob_type.clone(),
                    HashedValue::from(hello_world_string.clone()),
                ),
                small_blob_type.clone(),
            ),
        )
        .unwrap();
    let lambda_expression = TypedExpression::new(
        Expression::Lambda(Box::new(LambdaExpression::new(
            memory_byte_sink_type.clone(),
            lambda_parameter_name.clone(),
            write_expression.expression,
        ))),
        Type::Function(Box::new(Signature::new(
            memory_byte_sink_type.clone(),
            memory_byte_sink_type.clone(),
        ))),
    );
    {
        let mut program_as_string = String::new();
        lambda_expression
            .expression
            .print(&mut program_as_string, 0)
            .unwrap();
        assert_eq!("(output) =>\n  output.write(literal(SmallBlob, 8c2e63300f9624b6d77695ff7f60201ca23595096c40a535ab978db997204eec1066c3f3d42c868958bbbdfb7e9ce3a2d883e19512a90d94dbcc92c10b0a642f))", program_as_string.as_str());
    }
    let read_variable: Arc<ReadVariable> = Arc::new(
        move |_name: &Name| -> Pin<Box<dyn core::future::Future<Output = Pointer> + Send>> {
            todo!()
        },
    );
    let read_literal = move |literal_type: Type,
                             value: HashedValue|
          -> Pin<Box<dyn core::future::Future<Output = Pointer> + Send>> {
        assert_eq!(small_blob_type, literal_type);
        Box::pin(async move { Pointer::Value(value) })
    };
    let apply_name = Name::new(BUILTINS_NAMESPACE, LAMBDA_APPLY_METHOD_NAME.to_string());
    let lambda_interface = Arc::new(Interface::new(BTreeMap::from([(
        apply_name.clone(),
        Signature::new(memory_byte_sink_type.clone(), memory_byte_sink_type.clone()),
    )])));
    let lambda_interface_ref = store_object(&*storage, &*lambda_interface).await.unwrap();
    let main_function = evaluate(
        &lambda_expression.expression,
        &*storage,
        &read_variable,
        &read_literal,
    )
    .await;
    let result = main_function
        .call_method(
            &lambda_interface_ref,
            &apply_name,
            &Pointer::Object(Arc::new(MemoryByteSink {
                self_interface: memory_byte_sink_interface_ref,
                written: vec![],
            })),
            &*storage,
            &read_variable,
            &read_literal,
        )
        .await
        .unwrap();
    let serialized_result = match result {
        Pointer::Object(object) => object.serialize(&*storage).await.unwrap(),
        _ => panic!("Expected an object"),
    };
    let deserialized_result = MemoryByteSink::deserialize(serialized_result.value(), &*storage)
        .await
        .unwrap();
    assert_eq!(
        &memory_byte_sink_interface_ref,
        &deserialized_result.self_interface
    );
    assert_eq!(1, deserialized_result.written.len());
    assert_eq!(*hello_world_string, *deserialized_result.written[0]);
}

1	use crate::{
2	builtins::{BUILTINS_NAMESPACE, LAMBDA_APPLY_METHOD_NAME},
3	expressions::{
4	evaluate, Expression, LambdaExpression, Object, Pointer, ReadLiteral, ReadVariable,
5	},
6	types::{Interface, Name, NamespaceId, Signature, Type, TypedExpression},
7	};
8	use astraea::{
9	storage::{store_object, InMemoryValueStorage, LoadValue, StoreError, StoreValue},
10	tree::{BlobDigest, HashedValue, Value, ValueBlob},
11	};
12	use async_trait::async_trait;
13	use std::{collections::BTreeMap, pin::Pin, sync::Arc};
14
15	#[derive(Debug)]
16	struct MemoryByteSink {
17	pub self_interface: BlobDigest,
18	pub written: Vec<Arc<Value>>,
19	}
20
21	impl MemoryByteSink {
22	pub fn write_method_name() -> Name {	3✔
23	let namespace = NamespaceId([42; 16]);	3✔
24	Name::new(namespace, "write".to_string())	3✔
25	}
26
27	pub async fn deserialize(	1✔
28	serialized: &Value,
29	storage: &(dyn LoadValue + Sync),
30	) -> Option<MemoryByteSink> {
31	if serialized.blob().len() > 0 {	1✔
NEW 32	return None;	×
33	}
34	let mut references_iterator = serialized.references().iter();	1✔
35	let self_interface = references_iterator.next()?;	1✔
36	let mut written: Vec<Arc<Value>> = Vec::new();
37	written.reserve(references_iterator.len());
38	for reference in references_iterator {	3✔
39	let value = storage.load_value(reference).await?;	2✔
40	written.push(value.hash()?.value().clone());	1✔
41	}
42	Some(MemoryByteSink {	1✔
43	self_interface: *self_interface,	1✔
44	written,	1✔
45	})
46	}
47	}
48
49	#[async_trait]
50	impl Object for MemoryByteSink {
51	async fn call_method(
52	&self,
53	interface: &BlobDigest,
54	method: &Name,
55	argument: &Pointer,
56	_storage: &(dyn LoadValue + Sync),
57	_read_variable: &Arc<ReadVariable>,
58	_read_literal: &ReadLiteral,
59	) -> std::result::Result<Pointer, ()> {
60	if &self.self_interface == interface {	1✔
61	if &Self::write_method_name() == method {	1✔
62	let argument_value = match argument.serialize_to_flat_value().await {	2✔
63	Some(success) => success,	1✔
64	None => todo!(),
65	};
66	let mut new_written = self.written.clone();	1✔
67	new_written.push(argument_value);	1✔
68	Ok(Pointer::Object(Arc::new(MemoryByteSink {	1✔
69	self_interface: self.self_interface,	1✔
70	written: new_written,	1✔
71	})))
72	} else {
73	todo!()
74	}
75	} else {
76	todo!()
77	}
78	}
79
80	async fn serialize(
81	&self,
82	storage: &(dyn StoreValue + Sync),
83	) -> std::result::Result<HashedValue, StoreError> {
84	let mut references = Vec::new();	1✔
85	references.push(self.self_interface);	1✔
86	for value in &self.written {	3✔
87	references.push(	1✔
88	storage	1✔
89	.store_value(&HashedValue::from(value.clone()))	1✔
90	.await?,	1✔
91	);
92	}
93	Ok(HashedValue::from(Arc::new(Value::new(	1✔
94	ValueBlob::empty(),	1✔
95	references,	1✔
96	))))
97	}
98
NEW 99	async fn serialize_to_flat_value(&self) -> Option<Arc<Value>> {	×
100	todo!()
101	}
102	}
103
104	#[tokio::test]
105	async fn memory_byte_sink() {	2✔
106	let storage = Arc::new(InMemoryValueStorage::empty());	2✔
107	let namespace = NamespaceId([42; 16]);	2✔
108	let memory_byte_sink_name = Name::new(namespace, "MemoryByteSink".to_string());	2✔
109	let memory_byte_sink_type = Type::Named(memory_byte_sink_name);	2✔
110	let lambda_parameter_name = Name::new(namespace.clone(), "output".to_string());	2✔
111	let read_lambda_parameter_expression = TypedExpression::new(
112	Expression::ReadVariable(lambda_parameter_name.clone()),	2✔
113	memory_byte_sink_type.clone(),	2✔
114	);
115	let small_blob_name = Name::new(namespace, "SmallBlob".to_string());	2✔
116	let small_blob_type = Type::Named(small_blob_name);	2✔
117	let memory_byte_sink_interface = Arc::new(Interface::new(BTreeMap::from([(	2✔
118	MemoryByteSink::write_method_name(),	2✔
119	Signature::new(small_blob_type.clone(), memory_byte_sink_type.clone()),	2✔
120	)])));
121	let memory_byte_sink_interface_ref = store_object(&storage, &memory_byte_sink_interface)	3✔
122	.await	2✔
123	.unwrap();
124	let hello_world_string = Arc::new(Value::from_string("Hello, world!\n").unwrap());	2✔
125	let write_expression = read_lambda_parameter_expression	2✔
126	.apply(
127	&memory_byte_sink_interface,	2✔
128	&memory_byte_sink_interface_ref,	2✔
129	MemoryByteSink::write_method_name(),	2✔
130	TypedExpression::new(	2✔
131	Expression::Literal(	2✔
132	small_blob_type.clone(),	2✔
133	HashedValue::from(hello_world_string.clone()),	2✔
134	),
135	small_blob_type.clone(),	2✔
136	),
137	)
138	.unwrap();
139	let lambda_expression = TypedExpression::new(
140	Expression::Lambda(Box::new(LambdaExpression::new(	2✔
141	memory_byte_sink_type.clone(),	2✔
142	lambda_parameter_name.clone(),	2✔
143	write_expression.expression,	2✔
144	))),
145	Type::Function(Box::new(Signature::new(	2✔
146	memory_byte_sink_type.clone(),	2✔
147	memory_byte_sink_type.clone(),	2✔
148	))),
149	);
150	{
151	let mut program_as_string = String::new();	2✔
152	lambda_expression	2✔
153	.expression	2✔
154	.print(&mut program_as_string, 0)	2✔
155	.unwrap();
156	assert_eq!("(output) =>\n output.write(literal(SmallBlob, 8c2e63300f9624b6d77695ff7f60201ca23595096c40a535ab978db997204eec1066c3f3d42c868958bbbdfb7e9ce3a2d883e19512a90d94dbcc92c10b0a642f))", program_as_string.as_str());
157	}
158	let read_variable: Arc<ReadVariable> = Arc::new(
159	move \|_name: &Name\| -> Pin<Box<dyn core::future::Future<Output = Pointer> + Send>> {	2✔
160	todo!()	1✔
161	},
162	);
163	let read_literal = move \|literal_type: Type,	2✔
164	value: HashedValue\|	1✔
165	-> Pin<Box<dyn core::future::Future<Output = Pointer> + Send>> {	2✔
166	assert_eq!(small_blob_type, literal_type);
167	Box::pin(async move { Pointer::Value(value) })	4✔
168	};
169	let apply_name = Name::new(BUILTINS_NAMESPACE, LAMBDA_APPLY_METHOD_NAME.to_string());	2✔
170	let lambda_interface = Arc::new(Interface::new(BTreeMap::from([(	2✔
171	apply_name.clone(),	2✔
172	Signature::new(memory_byte_sink_type.clone(), memory_byte_sink_type.clone()),	2✔
173	)])));
174	let lambda_interface_ref = store_object(&storage, &lambda_interface).await.unwrap();	4✔
175	let main_function = evaluate(
176	&lambda_expression.expression,	2✔
177	&*storage,	2✔
178	&read_variable,	2✔
179	&read_literal,	2✔
180	)
181	.await;	2✔
182	let result = main_function	3✔
183	.call_method(
184	&lambda_interface_ref,	2✔
185	&apply_name,	2✔
186	&Pointer::Object(Arc::new(MemoryByteSink {	2✔
187	self_interface: memory_byte_sink_interface_ref,	2✔
188	written: vec![],	2✔
189	})),
190	&*storage,	2✔
191	&read_variable,	2✔
192	&read_literal,	2✔
193	)
194	.await	2✔
195	.unwrap();
196	let serialized_result = match result {	3✔
197	Pointer::Object(object) => object.serialize(&*storage).await.unwrap(),	3✔
198	_ => panic!("Expected an object"),
199	};
200	let deserialized_result = MemoryByteSink::deserialize(serialized_result.value(), &*storage)	3✔
201	.await	2✔
202	.unwrap();
203	assert_eq!(
204	&memory_byte_sink_interface_ref,
205	&deserialized_result.self_interface
206	);
207	assert_eq!(1, deserialized_result.written.len());
208	assert_eq!(hello_world_string, deserialized_result.written[0]);
209	}

TyRoXx / NonlocalityOS / 14426917358

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous