deno_core_test.rs

extern crate log;
extern crate futures;
extern crate deno_core;
extern crate tokio;

use deno_core::serde_json;
use deno_core::CoreIsolate;
use deno_core::CoreIsolateState;
use deno_core::ErrBox;
use deno_core::Script;
use deno_core::StartupData;
use deno_core::ZeroCopyBuf;
use std::env;

struct Logger;

impl log::Log for Logger {
  fn enabled(&self, metadata: &log::Metadata) -> bool {
    metadata.level() <= log::max_level()
  }

  fn log(&self, record: &log::Record) {
    if self.enabled(record.metadata()) {
      println!("{} - {}", record.level(), record.args());
    }
  }

  fn flush(&self) {}
}

pub fn isolate_new() -> CoreIsolate {
  let startup_data = StartupData::Script(Script {
    source: include_str!("test.js"),
    filename: "test.js",
  });

  let mut isolate = CoreIsolate::new(startup_data, false);

  isolate.register_op_json_sync("testy", op_testy);

  isolate
}

fn op_testy(
  _state: &mut CoreIsolateState,
  _args: serde_json::Value,
  _buf: &mut [ZeroCopyBuf],
) -> Result<serde_json::Value, ErrBox> {
  println!("testy");
  Ok(serde_json::json!(()))
}

fn main() {
  log::set_logger(&Logger).unwrap();
  log::set_max_level(
    env::args()
      .find(|a| a == "-D")
      .map(|_| log::LevelFilter::Debug)
      .unwrap_or(log::LevelFilter::Warn),
  );

  // NOTE: `--help` arg will display V8 help and exit
  deno_core::v8_set_flags(env::args().collect());

  let isolate = isolate_new();
  let mut runtime = tokio::runtime::Builder::new()
    .basic_scheduler()
    .enable_all()
    .build()
    .unwrap();
  deno_core::js_check(runtime.block_on(isolate));
}