test: add more spec tests (#9)

* test: add logger tests

* test: add legacy render tests

Author: ahabhgk

.github/workflows/ci.yml

@@ -46,12 +46,10 @@ jobs:
   test:
     name: 'Tests | ${{ matrix.os }}'
     runs-on: ${{ matrix.os }}-latest
-
     strategy:
       matrix:
         os: [ubuntu, macos, windows]
       fail-fast: false
-
     steps:
       - uses: actions/checkout@v3
       - uses: arduino/setup-protoc@v1
@@ -70,7 +68,26 @@ jobs:
           toolchain: 'stable'
           profile: minimal
           override: true
-      - name: test default features
-        run: cargo test -- --nocapture
-      - name: test legacy features
-        run: cargo test --features legacy -- --test-threads=1 --nocapture
+      # Since cargo test will run tests in parallel, and the crate uses cwd in
+      # legacy importer and captured stdio for testing logger, so we need to
+      # run tests in sequentially by adding `--test-threads=1`
+      - run: cargo test --all-features -- --test-threads=1 --nocapture
+
+  publish:
+    name: Publish
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions-rs/toolchain@v1
+        with:
+          toolchain: 'stable'
+          profile: minimal
+          override: true
+      - uses: obi1kenobi/cargo-semver-checks-action@v1
+      - name: publish
+        if: |
+          github.repository == 'ahabhgk/sass-embedded-host-rust' &&
+          startsWith(github.ref, 'refs/tags/')
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: cargo publish -vv

Cargo.toml

@@ -23,6 +23,8 @@ urlencoding = { version = "2", optional = true }
 [dev-dependencies]
 serde_json = "1"
 tempfile = "3"
+gag = "1"
+pathdiff = "0.2"
 
 [build-dependencies]
 prost-build = "0.11"

src/api.rs

@@ -126,8 +126,8 @@ impl OptionsBuilder {
     self
   }
 
-  pub fn logger(mut self, arg: impl Into<SassLogger>) -> Self {
-    self.options.logger = Some(arg.into());
+  pub fn logger<L: 'static + Logger>(mut self, arg: L) -> Self {
+    self.options.logger = Some(Box::new(arg));
     self
   }
 
@@ -275,8 +275,8 @@ impl StringOptionsBuilder {
     self
   }
 
-  pub fn logger(mut self, arg: impl Into<SassLogger>) -> Self {
-    self.options.logger = Some(arg.into());
+  pub fn logger<L: 'static + Logger>(mut self, arg: L) -> Self {
+    self.options.logger = Some(Box::new(arg));
     self
   }
 
@@ -313,19 +313,25 @@ impl StringOptionsBuilder {
 pub type SassLogger = Box<dyn Logger>;
 
 pub trait Logger: Debug + Send + Sync {
-  fn warn(&self, message: &str, options: &LoggerWarnOptions);
+  fn warn(&self, _message: &str, options: &LoggerWarnOptions) {
+    eprintln!("{}", options.formatted);
+  }
 
-  fn debug(&self, message: &str, options: &LoggerDebugOptions);
+  fn debug(&self, _message: &str, options: &LoggerDebugOptions) {
+    eprintln!("{}", options.formatted);
+  }
 }
 
 pub struct LoggerWarnOptions {
   pub deprecation: bool,
   pub span: Option<SourceSpan>,
   pub stack: Option<String>,
+  pub(crate) formatted: String,
 }
 
 pub struct LoggerDebugOptions {
   pub span: Option<SourceSpan>,
+  pub(crate) formatted: String,
 }
 
 #[derive(Debug)]

src/error.rs

@@ -6,7 +6,7 @@ use crate::protocol::{
 
 pub type Result<T> = std::result::Result<T, Exception>;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Exception {
   message: String,
   sass_message: Option<String>,

src/host/logger_registry.rs

@@ -16,7 +16,13 @@ impl LoggerRegistry {
   pub fn log(&self, event: LogEvent) {
     if let Some(logger) = &self.logger {
       if event.r#type() == LogEventType::Debug {
-        logger.debug(&event.message, &LoggerDebugOptions { span: event.span });
+        logger.debug(
+          &event.message,
+          &LoggerDebugOptions {
+            span: event.span,
+            formatted: event.formatted,
+          },
+        );
       } else {
         let deprecation = event.r#type() == LogEventType::DeprecationWarning;
         logger.warn(
@@ -29,6 +35,7 @@ impl LoggerRegistry {
             } else {
               Some(event.stack_trace)
             },
+            formatted: event.formatted,
           },
         );
       }

src/legacy.rs

@@ -6,7 +6,9 @@ use std::{sync::Arc, time::SystemTime};
 pub use api::*;
 pub use importer::*;
 
-use crate::{Embedded, Importer, Options, Result, SassImporter, StringOptions};
+use crate::{
+  Embedded, Exception, Importer, Options, Result, SassImporter, StringOptions,
+};
 
 impl Embedded {
   pub fn render(&mut self, options: LegacyOptions) -> Result<LegacyResult> {
@@ -65,8 +67,18 @@ impl Embedded {
       options.importers = importers;
       self.compile(file, options)
     } else {
-      panic!("Either options.data or options.file must be set.");
+      Err(Exception::new(
+        "Either options.data or options.file must be set.",
+      ))
     }?;
-    Ok(LegacyResult::new(entry, start, result))
+    Ok(LegacyResult::new(
+      if entry == "stdin" {
+        "data".to_string()
+      } else {
+        entry
+      },
+      start,
+      result,
+    ))
   }
 }

src/legacy/api.rs

@@ -10,7 +10,7 @@ use crate::{
   legacy::url_to_file_path_cross_platform, CompileResult, Options,
   StringOptions, Syntax, Url,
 };
-pub use crate::{OutputStyle, SassLogger};
+pub use crate::{Logger, OutputStyle, SassLogger};
 
 use super::{
   LegacyImporter, SassLegacyImporter, END_OF_LOAD_PROTOCOL,
@@ -244,8 +244,8 @@ impl LegacyOptionsBuilder {
     self
   }
 
-  pub fn logger(mut self, arg: impl Into<SassLogger>) -> Self {
-    self.options.logger = Some(arg.into());
+  pub fn logger<L: 'static + Logger>(mut self, arg: L) -> Self {
+    self.options.logger = Some(Box::new(arg));
     self
   }
 

src/lib.rs

@@ -21,3 +21,12 @@ pub use embedded::{Embedded, Embedded as Sass};
 pub use error::{Exception, Result};
 pub use protocol::{OutputStyle, SourceSpan, Syntax};
 pub use url::{self, Url};
+
+#[derive(Debug, Default, Clone)]
+pub struct Silent;
+
+impl Logger for Silent {
+  fn debug(&self, _: &str, _: &LoggerDebugOptions) {}
+
+  fn warn(&self, _: &str, _: &LoggerWarnOptions) {}
+}

tests/compile_spec.rs

@@ -1,4 +1,4 @@
-#[path = "./helpers.rs"]
+#[path = "helpers.rs"]
 mod helpers;
 
 use helpers::{exe_path, Sandbox, ToUrl};

tests/helpers.rs

@@ -1,9 +1,10 @@
 use std::{
   env, fs,
-  io::Write,
+  io::{Read, Write},
   path::{Path, PathBuf},
 };
 
+use gag::BufferRedirect;
 use sass_embedded_host_rust::{Sass, Url};
 use tempfile::TempDir;
 
@@ -55,9 +56,6 @@ impl Sandbox {
     self
   }
 
-  // Since cargo test will run tests in parallel, and the host uses the
-  // cwd when legacy is on, so we need to run legacy tests in sequentially
-  // by adding `--test-threads=1`
   #[cfg(feature = "legacy")]
   #[allow(dead_code)]
   pub fn chdir(&self) -> ChdirGuard {
@@ -75,6 +73,24 @@ impl Drop for ChdirGuard {
   }
 }
 
+#[derive(Debug, Clone)]
+pub struct Captured {
+  pub out: String,
+  pub err: String,
+}
+
+#[allow(dead_code)]
+pub fn capture_stdio(f: impl Fn()) -> Captured {
+  let mut stdout = BufferRedirect::stdout().unwrap();
+  let mut stderr = BufferRedirect::stderr().unwrap();
+  f();
+  let mut out = String::new();
+  let mut err = String::new();
+  stdout.read_to_string(&mut out).unwrap();
+  stderr.read_to_string(&mut err).unwrap();
+  Captured { out, err }
+}
+
 pub trait ToUrl {
   fn to_url(&self) -> Url;
 }