Add test for lambda and some edge cases for constant

crates/program_builder/src/lib.rs

@@ -1,32 +1,66 @@
-use uplc::ast::{Constant, DeBruijn, Name, Program, Term};
+#![cfg_attr(test, allow(non_snake_case))]
+
+use uplc::ast::{Constant, Name, Program, Term, Unique};
+
+#[cfg(test)]
+mod tests;
 
 #[derive(Default)]
 pub struct Builder {
-    // version: (usize, usize, usize),
+    version: (usize, usize, usize),
+    term_builder: TermBuilder,
 }
 
-impl Builder {
+#[derive(Clone)]
-    pub fn build_named(&self) -> Program<Name> {
+enum TermBuilder {
-        Program {
+    Null,
-            version: (11, 22, 33),
+    Constant(Constant),
-            term: Term::Constant(Constant::Integer(11)),
+    Lambda(Box<TermBuilder>),
+}
+
+impl TermBuilder {
+    pub fn build_named(&self) -> Term<Name> {
+        match self.clone() {
+            Self::Null => todo!("Make fallible?"),
+            Self::Constant(c) => Term::Constant(c),
+            Self::Lambda(term) => Term::Lambda {
+                parameter_name: Name {
+                    text: "i".to_string(),
+                    unique: Unique::new(0),
+                },
+                body: Box::new(term.build_named()),
+            },
         }
     }
 }
 
-#[cfg(test)]
+impl Default for TermBuilder {
-mod tests {
+    fn default() -> Self {
-    use crate::Builder;
+        Self::Null
-    use uplc::parser;
+    }
-
+}
-    #[test]
+
-    fn it_works() {
+impl Builder {
-        let code = r"(program
+    pub fn with_version(&mut self, maj: usize, min: usize, patch: usize) -> &mut Self {
-                           11.22.33
+        self.version = (maj, min, patch);
-                           (con integer 11)
+        self
-                         )";
+    }
-        let expected = parser::program(code).unwrap();
+
-        let actual = Builder::default().build_named();
+    pub fn with_constant_int(&mut self, int: isize) -> &mut Self {
-        assert_eq!(expected, actual);
+        self.term_builder = TermBuilder::Constant(Constant::Integer(int));
+        self
+    }
+
+    pub fn with_lambda(&mut self, int: isize) -> &mut Self {
+        let inner = TermBuilder::Constant(Constant::Integer(int));
+        self.term_builder = TermBuilder::Lambda(Box::new(inner));
+        self
+    }
+
+    pub fn build_named(&self) -> Program<Name> {
+        Program {
+            version: self.version,
+            term: self.term_builder.build_named(),
+        }
     }
 }

crates/program_builder/src/tests.rs

@@ -0,0 +1,58 @@
+use crate::Builder;
+use uplc::parser;
+
+#[test]
+fn build_named__with_const() {
+    let code = r"(program
+                       11.22.33
+                       (con integer 11)
+                     )";
+    let expected = parser::program(code).unwrap();
+    let actual = Builder::default()
+        .with_version(11, 22, 33)
+        .with_constant_int(11)
+        .build_named();
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn build_named__with_different_const() {
+    let code = r"(program
+                       11.22.33
+                       (con integer 22)
+                     )";
+    let expected = parser::program(code).unwrap();
+    let actual = Builder::default()
+        .with_version(11, 22, 33)
+        .with_constant_int(22)
+        .build_named();
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn build_named__with_const_different_version() {
+    let code = r"(program
+                       44.55.66
+                       (con integer 11)
+                     )";
+    let expected = parser::program(code).unwrap();
+    let actual = Builder::default()
+        .with_version(44, 55, 66)
+        .with_constant_int(11)
+        .build_named();
+    assert_eq!(expected, actual);
+}
+
+#[test]
+fn build_named__with_lam() {
+    let code = r"(program
+                       1.2.3
+                       (lam i_0 (con integer 1))
+                     )";
+    let expected = parser::program(code).unwrap();
+    let actual = Builder::default()
+        .with_version(1, 2, 3)
+        .with_lambda(1)
+        .build_named();
+    assert_eq!(expected, actual);
+}