feat: integration tests

TorstenDittmann · TorstenDittmann · commit a4c61df6ec74 · 2022-01-13T23:36:58.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -30,7 +30,8 @@ closure = []
 [workspace]
 members = [
     "crates/macros",
-    "crates/cli"
+    "crates/cli",
+    "tests"
 ]
 
 [package.metadata.docs.rs]
diff --git a/guide/src/types/binary.md b/guide/src/types/binary.md
@@ -43,7 +43,7 @@ pub fn test_binary(input: Binary<u32>) -> Binary<u32> {
 ```php
 <?php
 
-$data = pack('*L', [1, 2, 3, 4, 5]);
-$output = unpack('*L', test_binary($data));
+$data = pack('L*', 1, 2, 3, 4, 5);
+$output = unpack('L*', test_binary($data));
 var_dump($output); // array(5) { [0] => 5, [1] => 4, [2] => 3, [3] => 2, [4] => 1 }
 ```
diff --git a/tests/Cargo.toml b/tests/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "tests"
+version = "0.0.0"
+edition = "2021"
+publish = false
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+ext-php-rs = { path = "../", features = ["closure"] }
+
+[lib]
+crate-type = ["cdylib"]
diff --git a/tests/integration/array.php b/tests/integration/array.php
@@ -0,0 +1,3 @@
+<?php
+
+echo implode(' ', test_array(['a', 'b', 'c']));
diff --git a/tests/integration/array_assoc.php b/tests/integration/array_assoc.php
@@ -0,0 +1,13 @@
+<?php
+
+$output = '';
+
+foreach (test_array_assoc([
+    'first' => '1',
+    'second' => '2',
+    'third' => '3'
+]) as $key => $value) {
+    $output .= "{$key}={$value} ";
+}
+
+echo trim($output);
diff --git a/tests/integration/binary.php b/tests/integration/binary.php
@@ -0,0 +1,6 @@
+<?php
+
+
+$bin = test_binary(pack('L*', 1, 2, 3, 4, 5));
+
+echo implode(' ', unpack('L*', $bin));
diff --git a/tests/integration/bool.php b/tests/integration/bool.php
@@ -0,0 +1,9 @@
+<?php
+
+if (test_bool(true) === true) {
+    echo 'true ';
+}
+
+if (test_bool(false) === false) {
+    echo 'false';
+}
diff --git a/tests/integration/callable.php b/tests/integration/callable.php
@@ -0,0 +1,3 @@
+<?php
+
+echo test_callable(fn($a) => $a, 'callable works');
diff --git a/tests/integration/class.php b/tests/integration/class.php
@@ -0,0 +1,5 @@
+<?php
+
+$class = test_class("class", "works");
+
+echo $class->test();
diff --git a/tests/integration/closure.php b/tests/integration/closure.php
@@ -0,0 +1,3 @@
+<?php
+
+echo test_closure()('closure works');
diff --git a/tests/integration/closure_once.php b/tests/integration/closure_once.php
@@ -0,0 +1,11 @@
+<?php
+$clo = test_closure_once('closure works');
+
+echo $clo();
+echo ' ';
+
+try {
+    echo test_closure_once('twice');
+} catch (\Throwable $th) {
+    echo 'once';
+}
diff --git a/tests/integration/nullable.php b/tests/integration/nullable.php
@@ -0,0 +1,5 @@
+<?php
+
+echo test_nullable() ?? 'null';
+echo ' ';
+echo test_nullable('not_null') ?? 'null';
diff --git a/tests/integration/number_float.php b/tests/integration/number_float.php
@@ -0,0 +1,7 @@
+<?php
+
+echo test_number_float(round(-1.2, 2));
+echo ' ';
+echo test_number_float(round(0.0, 2));
+echo ' ';
+echo test_number_float(round(1.2, 2));
diff --git a/tests/integration/number_signed.php b/tests/integration/number_signed.php
@@ -0,0 +1,7 @@
+<?php
+
+echo test_number_signed(-12);
+echo ' ';
+echo test_number_signed(0);
+echo ' ';
+echo test_number_signed(12);
diff --git a/tests/integration/number_unsigned.php b/tests/integration/number_unsigned.php
@@ -0,0 +1,12 @@
+<?php
+
+try {
+    echo test_number_unsigned(-12);
+} catch (\Throwable $th) {
+    echo "thrown";
+    echo ' ';
+}
+
+echo test_number_unsigned(0);
+echo ' ';
+echo test_number_unsigned(12);
diff --git a/tests/integration/object.php b/tests/integration/object.php
@@ -0,0 +1,14 @@
+<?php
+
+$obj = new stdClass;
+$obj->first = 1;
+$obj->second = 2;
+$obj->third = 3;
+
+$output = '';
+
+foreach (test_object($obj) as $key => $value) {
+    $output .= "{$key}={$value} ";
+}
+
+echo trim($output);
diff --git a/tests/integration/str.php b/tests/integration/str.php
@@ -0,0 +1,3 @@
+<?php
+
+echo test_str('str works');
diff --git a/tests/integration/string.php b/tests/integration/string.php
@@ -0,0 +1,3 @@
+<?php
+
+echo test_string('string works');
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
@@ -0,0 +1,226 @@
+use ext_php_rs::{binary::Binary, prelude::*, types::ZendObject, types::Zval};
+use std::collections::HashMap;
+
+#[php_function]
+pub fn test_str(a: &str) -> &str {
+    a
+}
+
+#[php_function]
+pub fn test_string(a: String) -> String {
+    a
+}
+
+#[php_function]
+pub fn test_bool(a: bool) -> bool {
+    a
+}
+
+#[php_function]
+pub fn test_number_signed(a: i32) -> i32 {
+    a
+}
+
+#[php_function]
+pub fn test_number_unsigned(a: u32) -> u32 {
+    a
+}
+
+#[php_function]
+pub fn test_number_float(a: f32) -> f32 {
+    a
+}
+
+#[php_function]
+pub fn test_array(a: Vec<String>) -> Vec<String> {
+    a
+}
+
+#[php_function]
+pub fn test_array_assoc(a: HashMap<String, String>) -> HashMap<String, String> {
+    a
+}
+
+#[php_function]
+pub fn test_binary(a: Binary<u32>) -> Binary<u32> {
+    a
+}
+
+#[php_function]
+pub fn test_nullable(a: Option<String>) -> Option<String> {
+    a
+}
+
+#[php_function]
+pub fn test_object(a: &mut ZendObject) -> &mut ZendObject {
+    a
+}
+
+// TODO: not returning a closure
+#[php_function]
+pub fn test_closure() -> Closure {
+    Closure::wrap(Box::new(|a| a) as Box<dyn Fn(String) -> String>)
+}
+
+// TODO: not returning a closure
+#[php_function]
+pub fn test_closure_once(a: String) -> Closure {
+    let example = a.clone();
+    Closure::wrap_once(Box::new(move || example) as Box<dyn FnOnce() -> String>)
+}
+
+#[php_function]
+pub fn test_callable(call: ZendCallable, a: String) -> Zval {
+    call.try_call(vec![&a]).expect("Failed to call function")
+}
+
+#[php_class]
+pub struct TestClass {
+    foo: String,
+    bar: String,
+}
+
+#[php_impl]
+impl TestClass {
+    pub fn test(&self) -> String {
+        format!("{} {}", self.foo, self.bar)
+    }
+}
+
+#[php_function]
+pub fn test_class(foo: String, bar: String) -> TestClass {
+    TestClass { foo, bar }
+}
+
+#[php_module]
+pub fn get_module(module: ModuleBuilder) -> ModuleBuilder {
+    module
+}
+
+#[cfg(test)]
+mod tests {
+    use std::process::Command;
+    use std::sync::Once;
+
+    static BUILD: Once = Once::new();
+
+    #[cfg(target_os = "linux")]
+    const EXTENSION: &str = "so";
+    #[cfg(target_os = "macos")]
+    const EXTENSION: &str = "dylib";
+    #[cfg(target_os = "windows")]
+    const EXTENSION: &str = "dll";
+
+    fn setup() {
+        BUILD.call_once(|| {
+            Command::new("cargo")
+                .arg("build")
+                .output()
+                .expect("failed to execute process")
+                .status
+                .success();
+        });
+    }
+
+    fn run_php(file: &str) -> String {
+        setup();
+        String::from_utf8(
+            Command::new("php")
+                .arg(format!(
+                    "-dextension=../target/debug/libtests.{}",
+                    EXTENSION
+                ))
+                .arg(format!("integration/{}", file))
+                .output()
+                .expect("failed to run php file")
+                .stdout,
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn str_works() {
+        assert_eq!(run_php("str.php"), "str works");
+    }
+
+    #[test]
+    fn string_works() {
+        assert_eq!(run_php("string.php"), "string works");
+    }
+
+    #[test]
+    fn bool_works() {
+        assert_eq!(run_php("bool.php"), "true false");
+    }
+
+    #[test]
+    fn number_signed_works() {
+        assert_eq!(run_php("number_signed.php"), "-12 0 12");
+    }
+
+    #[test]
+    fn number_unsigned_works() {
+        assert_eq!(run_php("number_unsigned.php"), "thrown 0 12");
+    }
+
+    #[test]
+    fn number_float_works() {
+        let output = run_php("number_float.php");
+        let floats: Vec<f32> = output
+            .split_whitespace()
+            .map(|a| a.parse::<f32>().unwrap())
+            .collect();
+        assert_eq!(floats, vec![-1.2, 0.0, 1.2]);
+    }
+
+    #[test]
+    fn array_works() {
+        assert_eq!(run_php("array.php"), "a b c");
+    }
+
+    #[test]
+    fn array_assoc_works() {
+        let output = run_php("array_assoc.php");
+        assert_eq!(output.contains("first=1"), true);
+        assert_eq!(output.contains("second=2"), true);
+        assert_eq!(output.contains("third=3"), true);
+    }
+
+    #[test]
+    fn binary_works() {
+        assert_eq!(run_php("binary.php"), "1 2 3 4 5");
+    }
+
+    #[test]
+    fn nullable_works() {
+        assert_eq!(run_php("nullable.php"), "null not_null");
+    }
+
+    #[test]
+    fn object_works() {
+        let output = run_php("object.php");
+        assert_eq!(output.contains("first=1"), true);
+        assert_eq!(output.contains("second=2"), true);
+        assert_eq!(output.contains("third=3"), true);
+    }
+
+    #[test]
+    fn closure_works() {
+        assert_eq!(run_php("closure.php"), "closure works");
+    }
+
+    #[test]
+    fn closure_once_works() {
+        assert_eq!(run_php("closure_once.php"), "closure works once");
+    }
+
+    #[test]
+    fn callable_works() {
+        assert_eq!(run_php("callable.php"), "callable works");
+    }
+
+    #[test]
+    fn class_works() {
+        assert_eq!(run_php("class.php"), "class works");
+    }
+}

Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,8 @@ closure = []`
`30`	`30`	`[workspace]`
`31`	`31`	`members = [`
`32`	`32`	`"crates/macros",`
`33`		`- "crates/cli"`
	`33`	`+ "crates/cli",`
	`34`	`+ "tests"`
`34`	`35`	`]`
`35`	`36`
`36`	`37`	`[package.metadata.docs.rs]`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+<?php`
	`2`	`+`
	`3`	`+echo implode(' ', test_array(['a', 'b', 'c']));`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,6 @@ @@
 +<?php
++
++
 +$bin = test_binary(pack('L*', 1, 2, 3, 4, 5));
++
 +echo implode(' ', unpack('L*', $bin));
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+<?php`
	`2`	`+`
	`3`	`+echo test_callable(fn($a) => $a, 'callable works');`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+<?php`
	`2`	`+`
	`3`	`+echo test_closure()('closure works');`