You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: runner_test.rs
    path of file: ./repos/moon/crates/core/runner/tests
    
    the code of the file until where you have to start completion: use std::sync::Arc;

use moon::{generate_project_graph, load_workspace_from_sandbox};
use moon_action_context::ActionContext;
use moon_config::PlatformType;
use moon_console::Console;
use moon_emitter::Emitter;
use moon_platform_runtime::{Runtime, RuntimeReq};
use moon_runner::Runner;
use moon_test_utils::{create_sandbox_with_config, get_cases_fixture_configs, Sandbox};
use rustc_hash::FxHashSet;
use tokio::sync::RwLock;

fn cases_sandbox() -> Sandbox {
    let (workspace_config, toolchain_config, tasks_config) = get_cases_fixture_configs();

    create_sandbox_with_config(
        "cases",
        Some(workspace_config),
        Some(toolchain_config),
    
    
async fn dot_if_no_input_files() {
    let sandbox = cases_sandbox();
    sandbox.enable_git();

    let mut workspace = load_workspace_from_sandbox(sandbox.path()).await.unwrap();

    let project_graph = generate_project_graph(&mut workspace).await.unwrap();

    let project = project_graph.get("noAffected").unwrap();
    let task = project.get_task("misconfigured").unwrap();
    let emitter = Emitter::new(Arc::new(RwLock::new(workspace.clone())));

    let runner = Runner::new(
        &emitter,
        &workspace,
        &project,
        task,
        Arc::new(Console::new_testing()),
    )
    .unwrap();

    let cmd = runner
        .create_command(
            &ActionContext {
                affected_only: true,
                touched_files: FxHashSet::from_iter([]),
                ..Default::default()
            },
            &Runtime::new(PlatformType::Node, RuntimeReq::Global),
        )
        .await
        .unwrap();

    assert_eq!(cmd.args, vec!["./affected.js", "."]);
}