use std::io;
use std::process::Stdio;
use perforce_cli::P4Cli;
#[cfg(not(feature = "lt2016_2"))]
use perforce_cli::cmd::client::WorkSpaceType;
use perforce_cli::cmd::client::{Client, ShelvedHandling};
use perforce_cli::global::GlobalOpts;
use perforce_cli::spawn::ParameterizedSpawn;
mod common;
use common::{echo_bin, expect_args, expect_chain, parse_echo, spawned_args};
fn echo_client() -> Client {
Client::new(echo_bin("client"), GlobalOpts::new())
}
fn form_1_general() {
let p4 = P4Cli::default();
expect_chain!(["client"], p4.cmd_client());
expect_chain!(["client", "-f"], p4.cmd_client().force());
expect_chain!(["client", "-t", "tpl"], p4.cmd_client().template("tpl"));
expect_chain!(
["client", "-f", "-t", "tpl"],
p4.cmd_client().force().template("tpl")
);
let mut cmd = p4.cmd_client().template("tmp");
cmd.set_template("tpl");
assert_eq!(cmd.get_template(), "tpl");
expect_args(&cmd, &["client", "-t", "tpl"]);
#[cfg(not(feature = "lt2016_2"))]
{
let g = WorkSpaceType::Partitioned;
expect_chain!(
["client", "-T", "partitioned"],
p4.cmd_client().workspace_type(g)
);
expect_chain!(
["client", "-f", "-T", "partitioned"],
p4.cmd_client().force().workspace_type(g)
);
expect_chain!(
["client", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().template("tpl").workspace_type(g)
);
expect_chain!(
["client", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().workspace_type(g).template("tpl")
);
expect_chain!(
["client", "-f", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().force().template("tpl").workspace_type(g)
);
expect_chain!(
["client", "-f", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().force().workspace_type(g).template("tpl")
);
expect_chain!(
["client", "-f", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().template("tpl").force().workspace_type(g)
);
expect_chain!(
["client", "-f", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().template("tpl").workspace_type(g).force()
);
expect_chain!(
["client", "-f", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().workspace_type(g).force().template("tpl")
);
expect_chain!(
["client", "-f", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().workspace_type(g).template("tpl").force()
);
for (ty, value) in [
(WorkSpaceType::Writable, "writeable"),
(WorkSpaceType::Readonly, "readonly"),
(WorkSpaceType::Partitioned, "partitioned"),
#[cfg(not(feature = "lt2024_1"))]
(WorkSpaceType::PartitionedJnl, "partitioned-jnl"),
#[cfg(not(feature = "lt2024_1"))]
(WorkSpaceType::Graph, "graph"),
] {
expect_args(
&p4.cmd_client().workspace_type(ty),
&["client", "-T", value],
);
}
let mut cmd = p4
.cmd_client()
.template("tmp")
.workspace_type(WorkSpaceType::Readonly);
cmd.set_template("tpl").set_workspace_type(g);
assert_eq!(cmd.get_template(), "tpl");
assert_eq!(cmd.get_workspace_type(), g);
expect_args(&cmd, &["client", "-t", "tpl", "-T", "partitioned"]);
let mut cmd = echo_client().force().template("tpl").workspace_type(g);
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-f", "-t", "tpl", "-T", "partitioned", "ws-name"]
);
}
let mut cmd = echo_client();
assert_eq!(spawned_args(&mut cmd, ()), ["client"]);
let mut cmd = echo_client();
assert_eq!(spawned_args(&mut cmd, ("ws-name",)), ["client", "ws-name"]);
}
fn form_2_delete() {
let p4 = P4Cli::default();
expect_chain!(["client", "-d"], p4.cmd_client().delete());
expect_chain!(["client", "-d", "-f"], p4.cmd_client().delete().force());
expect_chain!(["client", "-d", "-f"], p4.cmd_client().force().delete());
expect_chain!(
["client", "-d", "-f", "-Fs"],
p4.cmd_client().delete().force().keep_shelved()
);
expect_chain!(
["client", "-d", "-f", "-Fs"],
p4.cmd_client().force().delete().keep_shelved()
);
expect_chain!(
["client", "-d", "-f", "-Fs"],
p4.cmd_client().force().keep_shelved()
);
expect_chain!(
["client", "-d", "-f", "-Fs"],
p4.cmd_client().keep_shelved().force()
);
expect_chain!(
["client", "-d", "-f", "-Fs"],
p4.cmd_client().delete().keep_shelved().force()
);
#[cfg(not(feature = "lt2024_1"))]
{
expect_chain!(
["client", "-d", "-f", "-Fd"],
p4.cmd_client().delete().force().delete_shelved()
);
expect_chain!(
["client", "-d", "-f", "-Fd"],
p4.cmd_client().force().delete().delete_shelved()
);
expect_chain!(
["client", "-d", "-f", "-Fd"],
p4.cmd_client().force().delete_shelved()
);
expect_chain!(
["client", "-d", "-f", "-Fd"],
p4.cmd_client().delete_shelved().force()
);
expect_chain!(
["client", "-d", "-f", "-Fd"],
p4.cmd_client().delete().delete_shelved().force()
);
let cmd = p4.cmd_client().delete_shelved().force();
assert_eq!(cmd.get_shelved(), Some(ShelvedHandling::Delete));
let mut cmd = echo_client().delete_shelved().force();
assert_eq!(
spawned_args(&mut cmd, ("old-ws",)),
["client", "-d", "-f", "-Fd", "old-ws"]
);
}
let cmd = p4.cmd_client().keep_shelved().force();
assert_eq!(cmd.get_shelved(), Some(ShelvedHandling::Keep));
let mut cmd = echo_client().delete();
assert_eq!(
spawned_args(&mut cmd, ("old-ws",)),
["client", "-d", "old-ws"]
);
let mut cmd = echo_client().keep_shelved().force();
assert_eq!(
spawned_args(&mut cmd, ("old-ws",)),
["client", "-d", "-f", "-Fs", "old-ws"]
);
}
fn form_3_stdout() {
let p4 = P4Cli::default();
expect_chain!(["client", "-o"], p4.cmd_client().stdout());
expect_chain!(
["client", "-o", "-t", "tpl"],
p4.cmd_client().template("tpl").stdout()
);
expect_chain!(
["client", "-o", "-t", "tpl"],
p4.cmd_client().stdout().template("tpl")
);
#[cfg(not(feature = "lt2016_2"))]
{
let y = WorkSpaceType::Partitioned;
expect_chain!(
["client", "-o", "-T", "partitioned"],
p4.cmd_client().workspace_type(y).stdout()
);
expect_chain!(
["client", "-o", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().template("tpl").workspace_type(y).stdout()
);
expect_chain!(
["client", "-o", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().workspace_type(y).template("tpl").stdout()
);
expect_chain!(
["client", "-o", "-T", "partitioned"],
p4.cmd_client().stdout().workspace_type(y)
);
expect_chain!(
["client", "-o", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().stdout().template("tpl").workspace_type(y)
);
expect_chain!(
["client", "-o", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().stdout().workspace_type(y).template("tpl")
);
expect_chain!(
["client", "-o", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().template("tpl").stdout().workspace_type(y)
);
expect_chain!(
["client", "-o", "-t", "tpl", "-T", "partitioned"],
p4.cmd_client().workspace_type(y).stdout().template("tpl")
);
let mut cmd = echo_client().template("tpl").workspace_type(y).stdout();
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-o", "-t", "tpl", "-T", "partitioned", "ws-name"]
);
}
let mut cmd = echo_client().stdout();
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-o", "ws-name"]
);
}
fn form_4_stream() {
let p4 = P4Cli::default();
let cmd = p4.cmd_client().stream("//stream/main");
assert_eq!(cmd.get_stream(), "//stream/main");
expect_args(&cmd, &["client", "-S", "//stream/main"]);
let mut cmd = p4.cmd_client().stream("old");
cmd.set_stream("//stream/dev");
expect_args(&cmd, &["client", "-S", "//stream/dev"]);
expect_chain!(
["client", "-S", "//stream/main", "-o"],
p4.cmd_client().stream("//stream/main").stdout()
);
let mut cmd = p4.cmd_client().stream("//stream/main").stdout();
assert_eq!(cmd.get_change(), None);
cmd.set_change("4321");
assert_eq!(cmd.get_change(), Some("4321"));
expect_args(&cmd, &["client", "-S", "//stream/main", "-c", "4321", "-o"]);
expect_chain!(
["client", "-S", "//stream/main", "-c", "4321", "-o"],
p4.cmd_client()
.stream("//stream/main")
.stdout()
.change("4321")
);
let mut cmd = echo_client().stream("//stream/main");
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-S", "//stream/main", "ws-name"]
);
let mut cmd = echo_client().stream("//stream/main").stdout();
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-S", "//stream/main", "-o", "ws-name"]
);
let mut cmd = echo_client()
.stream("//stream/main")
.stdout()
.change("4321");
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
[
"client",
"-S",
"//stream/main",
"-c",
"4321",
"-o",
"ws-name"
]
);
}
fn form_5_switch_stream() {
let p4 = P4Cli::default();
let cmd = p4.cmd_client().switch_view_stream("//stream/dev");
assert_eq!(cmd.get_stream(), "//stream/dev");
expect_args(&cmd, &["client", "-s", "-S", "//stream/dev"]);
let mut cmd = p4.cmd_client().switch_view_stream("old");
cmd.set_stream("//stream/dev");
expect_args(&cmd, &["client", "-s", "-S", "//stream/dev"]);
#[cfg(not(feature = "lt2022_1"))]
{
expect_chain!(
["client", "-s", "-f", "-S", "//stream/dev"],
p4.cmd_client().force().switch_view_stream("//stream/dev")
);
expect_chain!(
["client", "-s", "-f", "-S", "//stream/dev"],
p4.cmd_client().switch_view_stream("//stream/dev").force()
);
let mut cmd = p4.cmd_client().switch_view_stream("old");
cmd.set_stream("//stream/dev");
expect_args(&cmd.force(), &["client", "-s", "-f", "-S", "//stream/dev"]);
let mut cmd = p4.cmd_client().switch_view_stream("old").force();
cmd.set_stream("//stream/dev");
expect_args(&cmd, &["client", "-s", "-f", "-S", "//stream/dev"]);
expect_chain!(
["client", "-s", "-f", "-S", "//stream/dev"],
p4.cmd_client()
.switch_view_stream("old")
.force()
.stream("//stream/dev")
);
let cmd = p4.cmd_client().force().switch_view_stream("//stream/dev");
assert_eq!(cmd.get_stream(), "//stream/dev");
}
expect_chain!(
["client", "-s", "-S", "//stream/dev"],
p4.cmd_client().stream("//stream/dev").switch_view()
);
let mut cmd = p4.cmd_client().stream("old");
cmd.set_stream("//stream/dev");
expect_args(&cmd.switch_view(), &["client", "-s", "-S", "//stream/dev"]);
expect_chain!(
["client", "-s", "-S", "//stream/dev"],
p4.cmd_client()
.stream("old")
.stream("//stream/dev")
.switch_view()
);
#[cfg(not(feature = "lt2022_1"))]
{
expect_chain!(
["client", "-s", "-f", "-S", "//stream/dev"],
p4.cmd_client().stream("//stream/dev").switch_view().force()
);
}
let cmd = p4.cmd_client().stream("//stream/dev").switch_view();
assert_eq!(cmd.get_stream(), "//stream/dev");
let mut cmd = echo_client().switch_view_stream("//stream/dev");
assert_eq!(
spawned_args(&mut cmd, ()),
["client", "-s", "-S", "//stream/dev"]
);
#[cfg(not(feature = "lt2022_1"))]
{
let mut cmd = echo_client().force().switch_view_stream("//stream/dev");
assert_eq!(
spawned_args(&mut cmd, ()),
["client", "-s", "-f", "-S", "//stream/dev"]
);
let mut cmd = echo_client().switch_view_stream("//stream/dev").force();
assert_eq!(
spawned_args(&mut cmd, ()),
["client", "-s", "-f", "-S", "//stream/dev"]
);
}
let mut cmd = echo_client().switch_view_stream("//stream/dev");
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-s", "-S", "//stream/dev", "ws-name"]
);
#[cfg(not(feature = "lt2022_1"))]
{
let mut cmd = echo_client().force().switch_view_stream("//stream/dev");
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-s", "-f", "-S", "//stream/dev", "ws-name"]
);
let mut cmd = echo_client().switch_view_stream("//stream/dev").force();
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-s", "-f", "-S", "//stream/dev", "ws-name"]
);
}
let mut cmd = echo_client().stream("//stream/dev").switch_view();
assert_eq!(
spawned_args(&mut cmd, ()),
["client", "-s", "-S", "//stream/dev"]
);
#[cfg(not(feature = "lt2022_1"))]
{
let mut cmd = echo_client().stream("//stream/dev").switch_view().force();
assert_eq!(
spawned_args(&mut cmd, ()),
["client", "-s", "-f", "-S", "//stream/dev"]
);
}
let mut cmd = echo_client().stream("//stream/dev").switch_view();
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-s", "-S", "//stream/dev", "ws-name"]
);
#[cfg(not(feature = "lt2022_1"))]
{
let mut cmd = echo_client().stream("//stream/dev").switch_view().force();
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-s", "-f", "-S", "//stream/dev", "ws-name"]
);
}
}
fn form_6_switch_template() {
let p4 = P4Cli::default();
let cmd = p4.cmd_client().switch_view_template("tpl");
assert_eq!(cmd.get_template(), "tpl");
expect_args(&cmd, &["client", "-s", "-t", "tpl"]);
let mut cmd = p4.cmd_client().switch_view_template("old");
cmd.set_template("tpl");
expect_args(&cmd, &["client", "-s", "-t", "tpl"]);
expect_chain!(
["client", "-s", "-t", "tpl"],
p4.cmd_client().template("tpl").switch_view()
);
#[cfg(not(feature = "lt2022_1"))]
{
expect_chain!(
["client", "-s", "-f", "-t", "tpl"],
p4.cmd_client().force().switch_view_template("tpl")
);
expect_chain!(
["client", "-s", "-f", "-t", "tpl"],
p4.cmd_client().switch_view_template("tpl").force()
);
expect_chain!(
["client", "-s", "-f", "-t", "tpl"],
p4.cmd_client().force().template("tpl").switch_view()
);
expect_chain!(
["client", "-s", "-f", "-t", "tpl"],
p4.cmd_client().template("tpl").switch_view().force()
);
}
let mut cmd = echo_client().switch_view_template("tpl");
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-s", "-t", "tpl", "ws-name"]
);
#[cfg(not(feature = "lt2022_1"))]
{
let mut cmd = echo_client().force().switch_view_template("tpl");
assert_eq!(
spawned_args(&mut cmd, ("ws-name",)),
["client", "-s", "-f", "-t", "tpl", "ws-name"]
);
}
}
fn form_7_stdin() {
let p4 = P4Cli::default();
expect_chain!(["client", "-i"], p4.cmd_client().stdin());
expect_chain!(["client", "-i", "-f"], p4.cmd_client().force().stdin());
expect_chain!(["client", "-i", "-f"], p4.cmd_client().stdin().force());
let mut cmd = echo_client().stdin();
assert_eq!(spawned_args(&mut cmd, ()), ["client", "-i"]);
let mut cmd = echo_client().force().stdin();
let output = cmd
.spawn_with((Stdio::null(),))
.expect("spawn echo helper")
.wait_with_output()
.expect("wait for echo helper");
assert_eq!(parse_echo(&output.stdout), ["client", "-i", "-f"]);
}
#[cfg(not(feature = "lt2015_2"))]
fn form_8_server_id() {
let p4 = P4Cli::default();
let x = "edge.1667";
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667"],
p4.cmd_client().force().server_id(x)
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667"],
p4.cmd_client().server_id(x).force()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667"],
p4.cmd_client().delete().force().server_id(x)
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667"],
p4.cmd_client().force().delete().server_id(x)
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667"],
p4.cmd_client().delete().server_id(x).force()
);
let mut cmd = p4.cmd_client().server_id(x);
assert_eq!(cmd.get_server_id(), x);
assert_eq!(cmd.get_shelved(), None);
cmd.set_server_id("edge.42");
let cmd = cmd.force();
assert_eq!(cmd.get_server_id(), "edge.42");
expect_args(&cmd, &["client", "-d", "-f", "--serverid=edge.42"]);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().force().server_id(x).keep_shelved()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().force().keep_shelved().server_id(x)
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().server_id(x).force().keep_shelved()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().server_id(x).keep_shelved().force()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().keep_shelved().force().server_id(x)
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().keep_shelved().server_id(x).force()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().delete().force().server_id(x).keep_shelved()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().delete().force().keep_shelved().server_id(x)
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().delete().server_id(x).force().keep_shelved()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().delete().server_id(x).keep_shelved().force()
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().delete().keep_shelved().force().server_id(x)
);
expect_chain!(
["client", "-d", "-f", "--serverid=edge.1667", "-Fs"],
p4.cmd_client().delete().keep_shelved().server_id(x).force()
);
let cmd = p4.cmd_client().keep_shelved().server_id(x).force();
assert_eq!(cmd.get_server_id(), x);
assert_eq!(cmd.get_shelved(), Some(ShelvedHandling::Keep));
let mut cmd = echo_client().server_id(x).force();
assert_eq!(
spawned_args(&mut cmd, ("old-ws",)),
["client", "-d", "-f", "--serverid=edge.1667", "old-ws"]
);
let mut cmd = echo_client().keep_shelved().server_id(x).force();
assert_eq!(
spawned_args(&mut cmd, ("old-ws",)),
[
"client",
"-d",
"-f",
"--serverid=edge.1667",
"-Fs",
"old-ws"
]
);
}
fn main() -> io::Result<()> {
form_1_general();
form_2_delete();
form_3_stdout();
form_4_stream();
form_5_switch_stream();
form_6_switch_template();
form_7_stdin();
#[cfg(not(feature = "lt2015_2"))]
form_8_server_id();
println!("all p4 client syntax combinations verified");
Ok(())
}