mirror of
https://github.com/jj-vcs/jj.git
synced 2025-12-23 06:01:01 +00:00
5947632027
Tombi is an LSP that complains about the "$schema" key, because it itself is not actually part of our schema. Taplo is another LSP that can read this comment directive. Using a comment seems generally more appropriate. Syntax highlighting makes comments usually less visible, indicating that the directive is not actually part of the configuration data.
1729 lines
52 KiB
Rust
1729 lines
52 KiB
Rust
// Copyright 2022 The Jujutsu Authors
|
||
//
|
||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||
// you may not use this file except in compliance with the License.
|
||
// You may obtain a copy of the License at
|
||
//
|
||
// https://www.apache.org/licenses/LICENSE-2.0
|
||
//
|
||
// Unless required by applicable law or agreed to in writing, software
|
||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||
// See the License for the specific language governing permissions and
|
||
// limitations under the License.
|
||
|
||
use std::env::join_paths;
|
||
use std::path::PathBuf;
|
||
|
||
use indoc::indoc;
|
||
use itertools::Itertools as _;
|
||
use regex::Regex;
|
||
|
||
use crate::common::TestEnvironment;
|
||
use crate::common::default_config_from_schema;
|
||
use crate::common::fake_editor_path;
|
||
use crate::common::force_interactive;
|
||
use crate::common::to_toml_value;
|
||
|
||
#[test]
|
||
fn test_config_list_single() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
[test-table]
|
||
somekey = "some value"
|
||
"#,
|
||
);
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "list", "test-table.somekey"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-table.somekey = "some value"
|
||
[EOF]
|
||
"#);
|
||
|
||
let output = test_env.run_jj_in(
|
||
".",
|
||
["config", "list", r#"-Tname ++ "\n""#, "test-table.somekey"],
|
||
);
|
||
insta::assert_snapshot!(output, @r"
|
||
test-table.somekey
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_nonexistent() {
|
||
let test_env = TestEnvironment::default();
|
||
let output = test_env.run_jj_in(".", ["config", "list", "nonexistent-test-key"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Warning: No matching config key for nonexistent-test-key
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_table() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
[test-table]
|
||
x = true
|
||
y.foo = "abc"
|
||
y.bar = 123
|
||
"z"."with space"."function()" = 5
|
||
"#,
|
||
);
|
||
let output = test_env.run_jj_in(".", ["config", "list", "test-table"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-table.x = true
|
||
test-table.y.foo = "abc"
|
||
test-table.y.bar = 123
|
||
test-table.z."with space"."function()" = 5
|
||
[EOF]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_inline_table() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
test-table = { x = true, y = 1 }
|
||
"#,
|
||
);
|
||
// Inline tables are expanded
|
||
let output = test_env.run_jj_in(".", ["config", "list", "test-table"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
test-table.x = true
|
||
test-table.y = 1
|
||
[EOF]
|
||
");
|
||
// Inner value can also be addressed by a dotted name path
|
||
let output = test_env.run_jj_in(".", ["config", "list", "test-table.x"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
test-table.x = true
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_array() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
test-array = [1, "b", 3.4]
|
||
"#,
|
||
);
|
||
let output = test_env.run_jj_in(".", ["config", "list", "test-array"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-array = [1, "b", 3.4]
|
||
[EOF]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_array_of_tables() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
[[test-table]]
|
||
x = 1
|
||
[[test-table]]
|
||
y = ["z"]
|
||
z."key=with whitespace" = []
|
||
"#,
|
||
);
|
||
// Array is a value, so is array of tables
|
||
let output = test_env.run_jj_in(".", ["config", "list", "test-table"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-table = [{ x = 1 }, { y = ["z"], z = { "key=with whitespace" = [] } }]
|
||
[EOF]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_all() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
test-val = [1, 2, 3]
|
||
[test-table]
|
||
x = true
|
||
y.foo = "abc"
|
||
y.bar = 123
|
||
"#,
|
||
);
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "list"]);
|
||
insta::assert_snapshot!(
|
||
output.normalize_stdout_with(|s| find_stdout_lines(r"(test-val|test-table\b[^=]*)", &s)), @r#"
|
||
test-val = [1, 2, 3]
|
||
test-table.x = true
|
||
test-table.y.foo = "abc"
|
||
test-table.y.bar = 123
|
||
[EOF]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_multiline_string() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
multiline = '''
|
||
foo
|
||
bar
|
||
'''
|
||
"#,
|
||
);
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "list", "multiline"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
multiline = '''
|
||
foo
|
||
bar
|
||
'''
|
||
[EOF]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(
|
||
".",
|
||
[
|
||
"config",
|
||
"list",
|
||
"multiline",
|
||
"--include-overridden",
|
||
"--config=multiline='single'",
|
||
],
|
||
);
|
||
insta::assert_snapshot!(output, @r"
|
||
# multiline = '''
|
||
# foo
|
||
# bar
|
||
# '''
|
||
multiline = 'single'
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_layer() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.config_path().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
// User
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-key", "test-val"])
|
||
.success();
|
||
|
||
work_dir
|
||
.run_jj([
|
||
"config",
|
||
"set",
|
||
"--user",
|
||
"test-layered-key",
|
||
"test-original-val",
|
||
])
|
||
.success();
|
||
|
||
let output = work_dir.run_jj(["config", "list", "--user"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-key = "test-val"
|
||
test-layered-key = "test-original-val"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Repo
|
||
work_dir
|
||
.run_jj([
|
||
"config",
|
||
"set",
|
||
"--repo",
|
||
"test-layered-key",
|
||
"test-layered-val",
|
||
])
|
||
.success();
|
||
|
||
let output = work_dir.run_jj(["config", "list", "--user"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-key = "test-val"
|
||
[EOF]
|
||
"#);
|
||
|
||
let output = work_dir.run_jj(["config", "list", "--repo"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-layered-key = "test-layered-val"
|
||
[EOF]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_list_origin() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.config_path().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
// User
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-key", "test-val"])
|
||
.success();
|
||
|
||
work_dir
|
||
.run_jj([
|
||
"config",
|
||
"set",
|
||
"--user",
|
||
"test-layered-key",
|
||
"test-original-val",
|
||
])
|
||
.success();
|
||
|
||
// Repo
|
||
work_dir
|
||
.run_jj([
|
||
"config",
|
||
"set",
|
||
"--repo",
|
||
"test-layered-key",
|
||
"test-layered-val",
|
||
])
|
||
.success();
|
||
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
"-Tbuiltin_config_list_detailed",
|
||
"--config",
|
||
"test-cli-key=test-cli-val",
|
||
]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
test-key = "test-val" # user $TEST_ENV/config/config.toml
|
||
test-layered-key = "test-layered-val" # repo $TEST_ENV/repo/.jj/repo/config.toml
|
||
user.name = "Test User" # env
|
||
user.email = "test.user@example.com" # env
|
||
debug.commit-timestamp = "2001-02-03T04:05:11+07:00" # env
|
||
debug.randomness-seed = 5 # env
|
||
debug.operation-timestamp = "2001-02-03T04:05:11+07:00" # env
|
||
operation.hostname = "host.example.com" # env
|
||
operation.username = "test-username" # env
|
||
test-cli-key = "test-cli-val" # cli
|
||
[EOF]
|
||
"#);
|
||
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
"-Tbuiltin_config_list_detailed",
|
||
"--color=debug",
|
||
"--include-defaults",
|
||
"--include-overridden",
|
||
"--config=test-key=test-cli-val",
|
||
"test-key",
|
||
]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
[38;5;8m<<config_list overridden name::# test-key>><<config_list overridden:: = >><<config_list overridden value::"test-val">><<config_list overridden:: # >><<config_list overridden source::user>><<config_list overridden:: >><<config_list overridden path::$TEST_ENV/config/config.toml>><<config_list overridden::>>[39m
|
||
[38;5;2m<<config_list name::test-key>>[39m<<config_list:: = >>[38;5;3m<<config_list value::"test-cli-val">>[39m<<config_list:: # >>[38;5;4m<<config_list source::cli>>[39m<<config_list::>>
|
||
[EOF]
|
||
"#);
|
||
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
r#"-Tjson(self) ++ "\n""#,
|
||
"--include-defaults",
|
||
"--include-overridden",
|
||
"--config=test-key=test-cli-val",
|
||
"test-key",
|
||
]);
|
||
insta::with_settings!({
|
||
// Windows paths will be escaped in JSON syntax, which cannot be
|
||
// normalized as $TEST_ENV.
|
||
filters => [(r#""path":"[^"]*","#, r#""path":"<redacted>","#)],
|
||
}, {
|
||
insta::assert_snapshot!(output, @r#"
|
||
{"name":"test-key","value":"test-val","source":"user","path":"<redacted>","is_overridden":true}
|
||
{"name":"test-key","value":"test-cli-val","source":"cli","path":null,"is_overridden":false}
|
||
[EOF]
|
||
"#);
|
||
});
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_layer_override_default() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
let config_key = "merge-tools.vimdiff.program";
|
||
|
||
// Default
|
||
let output = work_dir.run_jj(["config", "list", config_key, "--include-defaults"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
merge-tools.vimdiff.program = "vim"
|
||
[EOF]
|
||
"#);
|
||
|
||
// User
|
||
test_env.add_config(format!(
|
||
"{config_key} = {value}\n",
|
||
value = to_toml_value("user")
|
||
));
|
||
let output = work_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
merge-tools.vimdiff.program = "user"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Repo
|
||
work_dir.write_file(
|
||
".jj/repo/config.toml",
|
||
format!("{config_key} = {value}\n", value = to_toml_value("repo")),
|
||
);
|
||
let output = work_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
merge-tools.vimdiff.program = "repo"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Command argument
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
config_key,
|
||
"--config",
|
||
&format!("{config_key}={value}", value = to_toml_value("command-arg")),
|
||
]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
merge-tools.vimdiff.program = "command-arg"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Allow printing overridden values
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
config_key,
|
||
"--include-overridden",
|
||
"--config",
|
||
&format!("{config_key}={value}", value = to_toml_value("command-arg")),
|
||
]);
|
||
insta::assert_snapshot!(output, @r##"
|
||
# merge-tools.vimdiff.program = "user"
|
||
# merge-tools.vimdiff.program = "repo"
|
||
merge-tools.vimdiff.program = "command-arg"
|
||
[EOF]
|
||
"##);
|
||
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
"--color=always",
|
||
config_key,
|
||
"--include-overridden",
|
||
]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
[38;5;8m# merge-tools.vimdiff.program = "user"[39m
|
||
[38;5;2mmerge-tools.vimdiff.program[39m = [38;5;3m"repo"[39m
|
||
[EOF]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_layer_override_env() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let config_key = "ui.editor";
|
||
|
||
// Environment base
|
||
test_env.add_env_var("EDITOR", "env-base");
|
||
let work_dir = test_env.work_dir("repo");
|
||
let output = work_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
ui.editor = "env-base"
|
||
[EOF]
|
||
"#);
|
||
|
||
// User
|
||
test_env.add_config(format!(
|
||
"{config_key} = {value}\n",
|
||
value = to_toml_value("user")
|
||
));
|
||
let output = work_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
ui.editor = "user"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Repo
|
||
work_dir.write_file(
|
||
".jj/repo/config.toml",
|
||
format!("{config_key} = {value}\n", value = to_toml_value("repo")),
|
||
);
|
||
let output = work_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
ui.editor = "repo"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Environment override
|
||
test_env.add_env_var("JJ_EDITOR", "env-override");
|
||
let work_dir = test_env.work_dir("repo");
|
||
let output = work_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
ui.editor = "env-override"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Command argument
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
config_key,
|
||
"--config",
|
||
&format!("{config_key}={value}", value = to_toml_value("command-arg")),
|
||
]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
ui.editor = "command-arg"
|
||
[EOF]
|
||
"#);
|
||
|
||
// Allow printing overridden values
|
||
let output = work_dir.run_jj([
|
||
"config",
|
||
"list",
|
||
config_key,
|
||
"--include-overridden",
|
||
"--config",
|
||
&format!("{config_key}={value}", value = to_toml_value("command-arg")),
|
||
]);
|
||
insta::assert_snapshot!(output, @r##"
|
||
# ui.editor = "env-base"
|
||
# ui.editor = "user"
|
||
# ui.editor = "repo"
|
||
# ui.editor = "env-override"
|
||
ui.editor = "command-arg"
|
||
[EOF]
|
||
"##);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_layer_workspace() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "main"]).success();
|
||
let main_dir = test_env.work_dir("main");
|
||
let secondary_dir = test_env.work_dir("secondary");
|
||
let config_key = "ui.editor";
|
||
|
||
main_dir.write_file("file", "contents");
|
||
main_dir.run_jj(["new"]).success();
|
||
main_dir
|
||
.run_jj(["workspace", "add", "--name", "second", "../secondary"])
|
||
.success();
|
||
|
||
// Repo
|
||
main_dir.write_file(
|
||
".jj/repo/config.toml",
|
||
format!(
|
||
"{config_key} = {value}\n",
|
||
value = to_toml_value("main-repo")
|
||
),
|
||
);
|
||
let output = main_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
ui.editor = "main-repo"
|
||
[EOF]
|
||
"#);
|
||
let output = secondary_dir.run_jj(["config", "list", config_key]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
ui.editor = "main-repo"
|
||
[EOF]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_set_bad_opts() {
|
||
let test_env = TestEnvironment::default();
|
||
let output = test_env.run_jj_in(".", ["config", "set"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
error: the following required arguments were not provided:
|
||
<--user|--repo>
|
||
<NAME>
|
||
<VALUE>
|
||
|
||
Usage: jj config set <--user|--repo> <NAME> <VALUE>
|
||
|
||
For more information, try '--help'.
|
||
[EOF]
|
||
[exit status: 2]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "set", "--user", "", "x"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
error: invalid value '' for '<NAME>': TOML parse error at line 1, column 1
|
||
|
|
||
1 |
|
||
| ^
|
||
unquoted keys cannot be empty, expected letters, numbers, `-`, `_`
|
||
|
||
|
||
For more information, try '--help'.
|
||
[EOF]
|
||
[exit status: 2]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "set", "--user", "x", "['typo'}"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
error: invalid value '['typo'}' for '<VALUE>': TOML parse error at line 1, column 8
|
||
|
|
||
1 | ['typo'}
|
||
| ^
|
||
missing comma between array elements, expected `,`
|
||
|
||
|
||
For more information, try '--help'.
|
||
[EOF]
|
||
[exit status: 2]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_set_for_user() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.config_path().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-key", "test-val"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-table.foo", "true"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-table.'bar()'", "0"])
|
||
.success();
|
||
|
||
// Ensure test-key successfully written to user config.
|
||
let user_config_toml = std::fs::read_to_string(&user_config_path)
|
||
.unwrap_or_else(|_| panic!("Failed to read file {}", user_config_path.display()));
|
||
insta::assert_snapshot!(user_config_toml, @r#"
|
||
#:schema https://jj-vcs.github.io/jj/latest/config-schema.json
|
||
|
||
test-key = "test-val"
|
||
|
||
[test-table]
|
||
foo = true
|
||
'bar()' = 0
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_set_for_user_directory() {
|
||
let test_env = TestEnvironment::default();
|
||
|
||
test_env
|
||
.run_jj_in(".", ["config", "set", "--user", "test-key", "test-val"])
|
||
.success();
|
||
insta::assert_snapshot!(
|
||
std::fs::read_to_string(test_env.last_config_file_path()).unwrap(),
|
||
@r#"
|
||
test-key = "test-val"
|
||
|
||
[template-aliases]
|
||
'format_time_range(time_range)' = 'time_range.start() ++ " - " ++ time_range.end()'
|
||
"#);
|
||
|
||
// Add one more config file to the directory
|
||
test_env.add_config("");
|
||
let output = test_env.run_jj_in(
|
||
".",
|
||
["config", "set", "--user", "test-key", "test-other-val"],
|
||
);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
1: $TEST_ENV/config/config0001.toml
|
||
2: $TEST_ENV/config/config0002.toml
|
||
Choose a config file (default 1): 1
|
||
[EOF]
|
||
");
|
||
|
||
insta::assert_snapshot!(
|
||
std::fs::read_to_string(test_env.first_config_file_path()).unwrap(),
|
||
@r#"
|
||
test-key = "test-other-val"
|
||
|
||
[template-aliases]
|
||
'format_time_range(time_range)' = 'time_range.start() ++ " - " ++ time_range.end()'
|
||
"#);
|
||
|
||
insta::assert_snapshot!(
|
||
std::fs::read_to_string(test_env.last_config_file_path()).unwrap(),
|
||
@"");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_set_for_repo() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
work_dir
|
||
.run_jj(["config", "set", "--repo", "test-key", "test-val"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "set", "--repo", "test-table.foo", "true"])
|
||
.success();
|
||
// Ensure test-key successfully written to user config.
|
||
let repo_config_toml = work_dir.read_file(".jj/repo/config.toml");
|
||
insta::assert_snapshot!(repo_config_toml, @r#"
|
||
#:schema https://jj-vcs.github.io/jj/latest/config-schema.json
|
||
|
||
test-key = "test-val"
|
||
|
||
[test-table]
|
||
foo = true
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_set_toml_types() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.config_path().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
let set_value = |key, value| {
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", key, value])
|
||
.success();
|
||
};
|
||
set_value("test-table.integer", "42");
|
||
set_value("test-table.float", "3.14");
|
||
set_value("test-table.array", r#"["one", "two"]"#);
|
||
set_value("test-table.boolean", "true");
|
||
set_value("test-table.string", r#""foo""#);
|
||
set_value("test-table.invalid", r"a + b");
|
||
insta::assert_snapshot!(std::fs::read_to_string(&user_config_path).unwrap(), @r#"
|
||
#:schema https://jj-vcs.github.io/jj/latest/config-schema.json
|
||
|
||
[test-table]
|
||
integer = 42
|
||
float = 3.14
|
||
array = ["one", "two"]
|
||
boolean = true
|
||
string = "foo"
|
||
invalid = "a + b"
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_set_type_mismatch() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-table.foo", "test-val"])
|
||
.success();
|
||
let output = work_dir.run_jj(["config", "set", "--user", "test-table", "not-a-table"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Error: Failed to set test-table
|
||
Caused by: Would overwrite entire table test-table
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
|
||
// But it's fine to overwrite arrays and inline tables
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-table.array", "[1,2,3]"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-table.array", "[4,5,6]"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-table.inline", "{ x = 42}"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-table.inline", "42"])
|
||
.success();
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_set_nontable_parent() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "test-nontable", "test-val"])
|
||
.success();
|
||
let output = work_dir.run_jj(["config", "set", "--user", "test-nontable.foo", "test-val"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Error: Failed to set test-nontable.foo
|
||
Caused by: Would overwrite non-table value with parent table test-nontable
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_unset_non_existent_key() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
let output = work_dir.run_jj(["config", "unset", "--user", "nonexistent"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
------- stderr -------
|
||
Error: "nonexistent" doesn't exist
|
||
[EOF]
|
||
[exit status: 1]
|
||
"#);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_unset_inline_table_key() {
|
||
let mut test_env = TestEnvironment::default();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.config_path().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "inline-table", "{ foo = true }"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "unset", "--user", "inline-table.foo"])
|
||
.success();
|
||
let user_config_toml = std::fs::read_to_string(&user_config_path).unwrap();
|
||
insta::assert_snapshot!(user_config_toml, @r"
|
||
#:schema https://jj-vcs.github.io/jj/latest/config-schema.json
|
||
|
||
inline-table = {}
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_unset_table_like() {
|
||
let mut test_env = TestEnvironment::default();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.config_path().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
|
||
std::fs::write(
|
||
&user_config_path,
|
||
indoc! {b"
|
||
inline-table = { foo = true }
|
||
[non-inline-table]
|
||
foo = true
|
||
"},
|
||
)
|
||
.unwrap();
|
||
|
||
// Inline table is syntactically a "value", so it can be deleted.
|
||
test_env
|
||
.run_jj_in(".", ["config", "unset", "--user", "inline-table"])
|
||
.success();
|
||
// Non-inline table cannot be deleted.
|
||
let output = test_env.run_jj_in(".", ["config", "unset", "--user", "non-inline-table"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Error: Failed to unset non-inline-table
|
||
Caused by: Would delete entire table non-inline-table
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
|
||
let user_config_toml = std::fs::read_to_string(&user_config_path).unwrap();
|
||
insta::assert_snapshot!(user_config_toml, @r"
|
||
[non-inline-table]
|
||
foo = true
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_unset_for_user() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.config_path().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "foo", "true"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "unset", "--user", "foo"])
|
||
.success();
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "table.foo", "true"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "unset", "--user", "table.foo"])
|
||
.success();
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "table.inline", "{ foo = true }"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "unset", "--user", "table.inline"])
|
||
.success();
|
||
|
||
let user_config_toml = std::fs::read_to_string(&user_config_path).unwrap();
|
||
insta::assert_snapshot!(user_config_toml, @"[table]");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_unset_for_repo() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--repo", "test-key", "test-val"])
|
||
.success();
|
||
work_dir
|
||
.run_jj(["config", "unset", "--repo", "test-key"])
|
||
.success();
|
||
|
||
let repo_config_toml = work_dir.read_file(".jj/repo/config.toml");
|
||
insta::assert_snapshot!(repo_config_toml, @"");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_edit_missing_opt() {
|
||
let test_env = TestEnvironment::default();
|
||
let output = test_env.run_jj_in(".", ["config", "edit"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
error: the following required arguments were not provided:
|
||
<--user|--repo>
|
||
|
||
Usage: jj config edit <--user|--repo>
|
||
|
||
For more information, try '--help'.
|
||
[EOF]
|
||
[exit status: 2]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_edit_user() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
// Remove one of the config file to disambiguate
|
||
std::fs::remove_file(test_env.last_config_file_path()).unwrap();
|
||
let edit_script = test_env.set_up_fake_editor();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
std::fs::write(edit_script, "dump-path path").unwrap();
|
||
work_dir.run_jj(["config", "edit", "--user"]).success();
|
||
|
||
let edited_path =
|
||
PathBuf::from(std::fs::read_to_string(test_env.env_root().join("path")).unwrap());
|
||
assert_eq!(
|
||
edited_path,
|
||
dunce::simplified(&test_env.last_config_file_path())
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_edit_user_new_file() {
|
||
let mut test_env = TestEnvironment::default();
|
||
let user_config_path = test_env.config_path().join("config").join("file.toml");
|
||
test_env.set_up_fake_editor(); // set $EDIT_SCRIPT, but added configuration is ignored
|
||
test_env.add_env_var("EDITOR", fake_editor_path());
|
||
test_env.set_config_path(&user_config_path);
|
||
assert!(!user_config_path.exists());
|
||
|
||
test_env
|
||
.run_jj_in(".", ["config", "edit", "--user"])
|
||
.success();
|
||
assert!(
|
||
user_config_path.exists(),
|
||
"new file and directory should be created"
|
||
);
|
||
}
|
||
|
||
// TODO: remove after deprecation period in 0.35
|
||
#[cfg_attr(not(target_os = "macos"), ignore)]
|
||
#[test]
|
||
fn test_config_edit_user_deprecated_file() {
|
||
let test_env = TestEnvironment::default();
|
||
let user_config_path = test_env
|
||
.home_dir()
|
||
.join("Library/Application Support/jj/config.toml");
|
||
std::fs::create_dir_all(user_config_path.parent().unwrap()).unwrap();
|
||
|
||
std::fs::write(
|
||
&user_config_path,
|
||
indoc! {b"
|
||
[foo]
|
||
bar = 'Make sure I can pick this up'
|
||
"},
|
||
)
|
||
.unwrap();
|
||
|
||
let output = test_env.run_jj_with(|cmd| {
|
||
cmd.env_remove("JJ_CONFIG")
|
||
.args(["config", "get", "foo.bar"])
|
||
});
|
||
insta::assert_snapshot!(output, @r"
|
||
Make sure I can pick this up
|
||
[EOF]
|
||
------- stderr -------
|
||
Warning: Deprecated configuration file `$TEST_ENV/home/Library/Application Support/jj/config.toml`.
|
||
Configuration files in `~/Library/Application Support/jj` are deprecated, and support will be removed in a future release.
|
||
Instead, move your configuration files to `~/.config/jj`.
|
||
[EOF]
|
||
");
|
||
|
||
// if XDG_CONFIG_HOME is ~/Library/Application Support,
|
||
// you shouldn't get a warning
|
||
let output = test_env.run_jj_with(|cmd| {
|
||
cmd.env_remove("JJ_CONFIG")
|
||
.env(
|
||
"XDG_CONFIG_HOME",
|
||
test_env.home_dir().join("Library/Application Support"),
|
||
)
|
||
.args(["config", "get", "foo.bar"])
|
||
});
|
||
insta::assert_snapshot!(output, @r"
|
||
Make sure I can pick this up
|
||
[EOF]
|
||
");
|
||
|
||
// if you set JJ_CONFIG, you shouldn't get a warning
|
||
let output = test_env.run_jj_with(|cmd| {
|
||
cmd.env("JJ_CONFIG", &user_config_path)
|
||
.args(["config", "get", "foo.bar"])
|
||
});
|
||
insta::assert_snapshot!(output, @r"
|
||
Make sure I can pick this up
|
||
[EOF]
|
||
");
|
||
|
||
let new_path = test_env.home_dir().join(".config/jj/config.toml");
|
||
std::fs::create_dir_all(new_path.parent().unwrap()).unwrap();
|
||
std::fs::rename(&user_config_path, &new_path).unwrap();
|
||
let output = test_env.run_jj_with(|cmd| {
|
||
cmd.env_remove("JJ_CONFIG")
|
||
.args(["config", "get", "foo.bar"])
|
||
});
|
||
insta::assert_snapshot!(output, @r"
|
||
Make sure I can pick this up
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_edit_repo() {
|
||
let mut test_env = TestEnvironment::default();
|
||
let edit_script = test_env.set_up_fake_editor();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
let repo_config_path = work_dir
|
||
.root()
|
||
.join(PathBuf::from_iter([".jj", "repo", "config.toml"]));
|
||
assert!(!repo_config_path.exists());
|
||
|
||
std::fs::write(edit_script, "dump-path path").unwrap();
|
||
work_dir.run_jj(["config", "edit", "--repo"]).success();
|
||
|
||
let edited_path =
|
||
PathBuf::from(std::fs::read_to_string(test_env.env_root().join("path")).unwrap());
|
||
assert_eq!(edited_path, dunce::simplified(&repo_config_path));
|
||
assert!(repo_config_path.exists(), "new file should be created");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_edit_invalid_config() {
|
||
let mut test_env = TestEnvironment::default();
|
||
let edit_script = test_env.set_up_fake_editor();
|
||
|
||
// Test re-edit
|
||
std::fs::write(
|
||
&edit_script,
|
||
"write\ninvalid config here\0next invocation\n\0write\ntest=\"success\"",
|
||
)
|
||
.unwrap();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
let output = work_dir.run_jj_with(|cmd| {
|
||
force_interactive(cmd)
|
||
.args(["config", "edit", "--repo"])
|
||
.write_stdin("Y\n")
|
||
});
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Editing file: $TEST_ENV/repo/.jj/repo/config.toml
|
||
Warning: An error has been found inside the config:
|
||
Caused by:
|
||
1: Configuration cannot be parsed as TOML document
|
||
2: TOML parse error at line 1, column 9
|
||
|
|
||
1 | invalid config here
|
||
| ^
|
||
key with no value, expected `=`
|
||
|
||
Do you want to keep editing the file? If not, previous config will be restored. (Yn): [EOF]
|
||
");
|
||
|
||
let output = work_dir.run_jj(["config", "get", "test"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
success
|
||
[EOF]"
|
||
);
|
||
|
||
// Test the restore previous config
|
||
std::fs::write(&edit_script, "write\ninvalid config here").unwrap();
|
||
let work_dir = test_env.work_dir("repo");
|
||
let output = work_dir.run_jj_with(|cmd| {
|
||
force_interactive(cmd)
|
||
.args(["config", "edit", "--repo"])
|
||
.write_stdin("n\n")
|
||
});
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Editing file: $TEST_ENV/repo/.jj/repo/config.toml
|
||
Warning: An error has been found inside the config:
|
||
Caused by:
|
||
1: Configuration cannot be parsed as TOML document
|
||
2: TOML parse error at line 1, column 9
|
||
|
|
||
1 | invalid config here
|
||
| ^
|
||
key with no value, expected `=`
|
||
|
||
Do you want to keep editing the file? If not, previous config will be restored. (Yn): [EOF]
|
||
");
|
||
|
||
let output = work_dir.run_jj(["config", "get", "test"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
success
|
||
[EOF]"
|
||
);
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_path() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
let user_config_path = test_env.env_root().join("config.toml");
|
||
let repo_config_path = work_dir
|
||
.root()
|
||
.join(PathBuf::from_iter([".jj", "repo", "config.toml"]));
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
insta::assert_snapshot!(work_dir.run_jj(["config", "path", "--user"]), @r"
|
||
$TEST_ENV/config.toml
|
||
[EOF]
|
||
");
|
||
assert!(
|
||
!user_config_path.exists(),
|
||
"jj config path shouldn't create new file"
|
||
);
|
||
|
||
insta::assert_snapshot!(work_dir.run_jj(["config", "path", "--repo"]), @r"
|
||
$TEST_ENV/repo/.jj/repo/config.toml
|
||
[EOF]
|
||
");
|
||
assert!(
|
||
!repo_config_path.exists(),
|
||
"jj config path shouldn't create new file"
|
||
);
|
||
|
||
insta::assert_snapshot!(test_env.run_jj_in(".", ["config", "path", "--repo"]), @r"
|
||
------- stderr -------
|
||
Error: No repo config path found
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_path_multiple() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let config_path = test_env.config_path().join("config.toml");
|
||
let work_config_path = test_env.config_path().join("conf.d");
|
||
let user_config_path = join_paths([config_path, work_config_path]).unwrap();
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
insta::assert_snapshot!(work_dir.run_jj(["config", "path", "--user"]), @r"
|
||
$TEST_ENV/config/config.toml
|
||
$TEST_ENV/config/conf.d
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_only_loads_toml_files() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.set_up_fake_editor();
|
||
std::fs::File::create(test_env.config_path().join("is-not.loaded")).unwrap();
|
||
insta::assert_snapshot!(test_env.run_jj_in(".", ["config", "edit", "--user"]), @r"
|
||
------- stderr -------
|
||
1: $TEST_ENV/config/config0001.toml
|
||
2: $TEST_ENV/config/config0002.toml
|
||
Choose a config file (default 1): 1
|
||
Editing file: $TEST_ENV/config/config0001.toml
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_edit_repo_outside_repo() {
|
||
let test_env = TestEnvironment::default();
|
||
let output = test_env.run_jj_in(".", ["config", "edit", "--repo"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Error: No repo config path found to edit
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_get() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
[table]
|
||
string = "some value 1"
|
||
int = 123
|
||
list = ["list", "value"]
|
||
overridden = "foo"
|
||
"#,
|
||
);
|
||
test_env.add_config(
|
||
r#"
|
||
[table]
|
||
overridden = "bar"
|
||
"#,
|
||
);
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "get", "nonexistent"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Config error: Value not found for nonexistent
|
||
For help, see https://jj-vcs.github.io/jj/latest/config/ or use `jj help -k config`.
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "get", "table.string"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
some value 1
|
||
[EOF]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "get", "table.int"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
123
|
||
[EOF]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "get", "table.list"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Config error: Invalid type or value for table.list
|
||
Caused by: Expected a value convertible to a string, but is an array
|
||
Hint: Check the config file: $TEST_ENV/config/config0002.toml
|
||
For help, see https://jj-vcs.github.io/jj/latest/config/ or use `jj help -k config`.
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "get", "table"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Config error: Invalid type or value for table
|
||
Caused by: Expected a value convertible to a string, but is a table
|
||
Hint: Check the config file: $TEST_ENV/config/config0003.toml
|
||
For help, see https://jj-vcs.github.io/jj/latest/config/ or use `jj help -k config`.
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "get", "table.overridden"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
bar
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_get_yields_values_consistent_with_schema_defaults() {
|
||
let test_env = TestEnvironment::default();
|
||
let get_true_default = move |key: &str| {
|
||
let output = test_env.run_jj_in(".", ["config", "get", key]).success();
|
||
let output_doc = toml_edit::Document::parse(format!("test={}", output.stdout.normalized()))
|
||
.unwrap_or_else(|_| {
|
||
// Unfortunately for this test, `config get` is "lossy" and does not print
|
||
// quoted strings. This means that e.g. `false` and `"false"` are not
|
||
// distinguishable. If value couldn't be parsed, it's probably a string, so
|
||
// let's parse its Debug string instead.
|
||
toml_edit::Document::parse(format!("test={:?}", output.stdout.normalized().trim()))
|
||
.unwrap()
|
||
});
|
||
output_doc.get("test").unwrap().as_value().unwrap().clone()
|
||
};
|
||
|
||
let mut schema_defaults = toml_edit::ser::to_document(&default_config_from_schema()).unwrap();
|
||
|
||
// Ensure that `get_values()` flattens the entire configuration.
|
||
struct SetDotted;
|
||
impl toml_edit::visit_mut::VisitMut for SetDotted {
|
||
fn visit_table_like_mut(&mut self, node: &mut dyn toml_edit::TableLike) {
|
||
node.set_dotted(true);
|
||
toml_edit::visit_mut::visit_table_like_mut(self, node);
|
||
}
|
||
}
|
||
toml_edit::visit_mut::visit_document_mut(&mut SetDotted, &mut schema_defaults);
|
||
|
||
for (key, schema_default) in schema_defaults.into_table().get_values() {
|
||
let key = key.iter().join(".");
|
||
match key.as_str() {
|
||
// These keys technically don't have a default value, but they exhibit a default
|
||
// behavior consistent with the value claimed by the schema. When these defaults are
|
||
// used, a hint is printed to stdout.
|
||
"ui.default-command" => insta::assert_snapshot!(schema_default, @r#""log""#),
|
||
"ui.diff-editor" => insta::assert_snapshot!(schema_default, @r#"":builtin""#),
|
||
"ui.merge-editor" => insta::assert_snapshot!(schema_default, @r#"":builtin""#),
|
||
"git.fetch" => insta::assert_snapshot!(schema_default, @r#""origin""#),
|
||
"git.push" => insta::assert_snapshot!(schema_default, @r#""origin""#),
|
||
|
||
// When no `short-prefixes` revset is explicitly configured, the revset for `log` is
|
||
// used instead, even if that has a value different from the default. The schema
|
||
// represents this behavior with a symbolic default value.
|
||
"revsets.short-prefixes" => {
|
||
insta::assert_snapshot!(schema_default, @r#""<revsets.log>""#);
|
||
}
|
||
|
||
// The default for `ui.pager` is a table; `ui.pager.command` is an array and `jj config
|
||
// get` currently cannot print that. The schema default omits the env variable
|
||
// `LESSCHARSET` and gives the default as a plain string.
|
||
"ui.pager" => insta::assert_snapshot!(schema_default, @r#""less -FRX""#),
|
||
|
||
// The `immutable_heads()` revset actually defaults to `builtin_immutable_heads()` but
|
||
// this would be a poor starting point for a custom revset, so the schema "inlines"
|
||
// `builtin_immutable_heads()`.
|
||
r#"revset-aliases."immutable_heads()""# => {
|
||
let builtin_default =
|
||
get_true_default("revset-aliases.'builtin_immutable_heads()'");
|
||
assert!(
|
||
builtin_default.to_string() == schema_default.to_string(),
|
||
"{key}: the schema claims a default ({schema_default}) which is different \
|
||
from what builtin_immutable_heads() resolves to ({builtin_default})"
|
||
);
|
||
}
|
||
|
||
_ => {
|
||
let true_default = get_true_default(&key);
|
||
assert!(
|
||
true_default.to_string() == schema_default.to_string(),
|
||
"{key}: true default value ({true_default}) is not consistent with default \
|
||
claimed by schema ({schema_default})"
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_path_syntax() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.add_config(
|
||
r#"
|
||
a.'b()' = 0
|
||
'b c'.d = 1
|
||
'b c'.e.'f[]' = 2
|
||
- = 3
|
||
_ = 4
|
||
'.' = 5
|
||
"#,
|
||
);
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "list", "a.'b()'"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
a.'b()' = 0
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "list", "'b c'"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
'b c'.d = 1
|
||
'b c'.e."f[]" = 2
|
||
[EOF]
|
||
"#);
|
||
let output = test_env.run_jj_in(".", ["config", "list", "'b c'.d"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
'b c'.d = 1
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "list", "'b c'.e.'f[]'"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
'b c'.e.'f[]' = 2
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "get", "'b c'.e.'f[]'"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
2
|
||
[EOF]
|
||
");
|
||
|
||
// Not a table
|
||
let output = test_env.run_jj_in(".", ["config", "list", "a.'b()'.x"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Warning: No matching config key for a.'b()'.x
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "get", "a.'b()'.x"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Config error: Value not found for a.'b()'.x
|
||
For help, see https://jj-vcs.github.io/jj/latest/config/ or use `jj help -k config`.
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
|
||
// "-" and "_" are valid TOML keys
|
||
let output = test_env.run_jj_in(".", ["config", "list", "-"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
- = 3
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "list", "_"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
_ = 4
|
||
[EOF]
|
||
");
|
||
|
||
// "." requires quoting
|
||
let output = test_env.run_jj_in(".", ["config", "list", "'.'"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
'.' = 5
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "get", "'.'"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
5
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "get", "."]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
error: invalid value '.' for '<NAME>': TOML parse error at line 1, column 1
|
||
|
|
||
1 | .
|
||
| ^
|
||
unquoted keys cannot be empty, expected letters, numbers, `-`, `_`
|
||
|
||
|
||
For more information, try '--help'.
|
||
[EOF]
|
||
[exit status: 2]
|
||
");
|
||
|
||
// Invalid TOML keys
|
||
let output = test_env.run_jj_in(".", ["config", "list", "b c"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
error: invalid value 'b c' for '[NAME]': TOML parse error at line 1, column 3
|
||
|
|
||
1 | b c
|
||
| ^
|
||
unexpected content, expected nothing
|
||
|
||
|
||
For more information, try '--help'.
|
||
[EOF]
|
||
[exit status: 2]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "list", ""]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
error: invalid value '' for '[NAME]': TOML parse error at line 1, column 1
|
||
|
|
||
1 |
|
||
| ^
|
||
unquoted keys cannot be empty, expected letters, numbers, `-`, `_`
|
||
|
||
|
||
For more information, try '--help'.
|
||
[EOF]
|
||
[exit status: 2]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
#[cfg_attr(windows, ignore = "dirs::home_dir() can't be overridden by $HOME")] // TODO
|
||
fn test_config_conditional() {
|
||
let mut test_env = TestEnvironment::default();
|
||
let home_dir = test_env.work_dir(test_env.home_dir());
|
||
home_dir.run_jj(["git", "init", "repo1"]).success();
|
||
home_dir.run_jj(["git", "init", "repo2"]).success();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.env_root().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
std::fs::write(
|
||
&user_config_path,
|
||
indoc! {"
|
||
foo = 'global'
|
||
baz = 'global'
|
||
qux = 'global'
|
||
|
||
[[--scope]]
|
||
--when.repositories = ['~/repo1']
|
||
foo = 'repo1'
|
||
[[--scope]]
|
||
--when.repositories = ['~/repo2']
|
||
foo = 'repo2'
|
||
|
||
[[--scope]]
|
||
--when.commands = ['config']
|
||
baz = 'config'
|
||
[[--scope]]
|
||
--when.commands = ['config get']
|
||
qux = 'get'
|
||
[[--scope]]
|
||
--when.commands = ['config list']
|
||
qux = 'list'
|
||
"},
|
||
)
|
||
.unwrap();
|
||
let home_dir = test_env.work_dir(test_env.home_dir());
|
||
let work_dir1 = home_dir.dir("repo1");
|
||
let work_dir2 = home_dir.dir("repo2");
|
||
|
||
// get and list should refer to the resolved config
|
||
let output = test_env.run_jj_in(".", ["config", "get", "foo"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
global
|
||
[EOF]
|
||
");
|
||
let output = work_dir1.run_jj(["config", "get", "foo"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
repo1
|
||
[EOF]
|
||
");
|
||
// baz should be the same for `jj config get` and `jj config list`
|
||
// qux should be different
|
||
let output = work_dir1.run_jj(["config", "get", "baz"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
config
|
||
[EOF]
|
||
");
|
||
let output = work_dir1.run_jj(["config", "get", "qux"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
get
|
||
[EOF]
|
||
");
|
||
let output = test_env.run_jj_in(".", ["config", "list", "--user"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
foo = 'global'
|
||
baz = 'config'
|
||
qux = 'list'
|
||
[EOF]
|
||
");
|
||
let output = work_dir1.run_jj(["config", "list", "--user"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
foo = 'repo1'
|
||
baz = 'config'
|
||
qux = 'list'
|
||
[EOF]
|
||
");
|
||
let output = work_dir2.run_jj(["config", "list", "--user"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
foo = 'repo2'
|
||
baz = 'config'
|
||
qux = 'list'
|
||
[EOF]
|
||
");
|
||
|
||
// relative workspace path
|
||
let output = work_dir2.run_jj(["config", "list", "--user", "-R../repo1"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
foo = 'repo1'
|
||
baz = 'config'
|
||
qux = 'list'
|
||
[EOF]
|
||
");
|
||
|
||
// set and unset should refer to the source config
|
||
// (there's no option to update scoped table right now.)
|
||
let output = test_env.run_jj_in(".", ["config", "set", "--user", "bar", "new value"]);
|
||
insta::assert_snapshot!(output, @"");
|
||
insta::assert_snapshot!(std::fs::read_to_string(&user_config_path).unwrap(), @r#"
|
||
foo = 'global'
|
||
baz = 'global'
|
||
qux = 'global'
|
||
bar = "new value"
|
||
|
||
[[--scope]]
|
||
--when.repositories = ['~/repo1']
|
||
foo = 'repo1'
|
||
[[--scope]]
|
||
--when.repositories = ['~/repo2']
|
||
foo = 'repo2'
|
||
|
||
[[--scope]]
|
||
--when.commands = ['config']
|
||
baz = 'config'
|
||
[[--scope]]
|
||
--when.commands = ['config get']
|
||
qux = 'get'
|
||
[[--scope]]
|
||
--when.commands = ['config list']
|
||
qux = 'list'
|
||
"#);
|
||
let output = work_dir1.run_jj(["config", "unset", "--user", "foo"]);
|
||
insta::assert_snapshot!(output, @"");
|
||
insta::assert_snapshot!(std::fs::read_to_string(&user_config_path).unwrap(), @r#"
|
||
baz = 'global'
|
||
qux = 'global'
|
||
bar = "new value"
|
||
|
||
[[--scope]]
|
||
--when.repositories = ['~/repo1']
|
||
foo = 'repo1'
|
||
[[--scope]]
|
||
--when.repositories = ['~/repo2']
|
||
foo = 'repo2'
|
||
|
||
[[--scope]]
|
||
--when.commands = ['config']
|
||
baz = 'config'
|
||
[[--scope]]
|
||
--when.commands = ['config get']
|
||
qux = 'get'
|
||
[[--scope]]
|
||
--when.commands = ['config list']
|
||
qux = 'list'
|
||
"#);
|
||
}
|
||
|
||
// Minimal test for Windows where the home directory can't be switched.
|
||
// (Can be removed if test_config_conditional() is enabled on Windows.)
|
||
#[test]
|
||
fn test_config_conditional_without_home_dir() {
|
||
let mut test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
// Test with fresh new config file
|
||
let user_config_path = test_env.env_root().join("config.toml");
|
||
test_env.set_config_path(&user_config_path);
|
||
let work_dir = test_env.work_dir("repo");
|
||
std::fs::write(
|
||
&user_config_path,
|
||
format!(
|
||
indoc! {"
|
||
foo = 'global'
|
||
[[--scope]]
|
||
--when.repositories = [{repo_path}]
|
||
foo = 'repo'
|
||
"},
|
||
// "\\?\" paths shouldn't be required on Windows
|
||
repo_path = to_toml_value(dunce::simplified(work_dir.root()).to_str().unwrap())
|
||
),
|
||
)
|
||
.unwrap();
|
||
|
||
let output = test_env.run_jj_in(".", ["config", "get", "foo"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
global
|
||
[EOF]
|
||
");
|
||
let output = work_dir.run_jj(["config", "get", "foo"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
repo
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_show_paths() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
|
||
work_dir
|
||
.run_jj(["config", "set", "--user", "ui.paginate", ":builtin"])
|
||
.success();
|
||
let output = test_env.run_jj_in(".", ["st"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
------- stderr -------
|
||
Config error: Invalid type or value for ui.paginate
|
||
Caused by: unknown variant `:builtin`, expected `never` or `auto`
|
||
|
||
Hint: Check the config file: $TEST_ENV/config/config0001.toml
|
||
For help, see https://jj-vcs.github.io/jj/latest/config/ or use `jj help -k config`.
|
||
[EOF]
|
||
[exit status: 1]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_author_change_warning() {
|
||
let test_env = TestEnvironment::default();
|
||
test_env.run_jj_in(".", ["git", "init", "repo"]).success();
|
||
let work_dir = test_env.work_dir("repo");
|
||
let output = work_dir.run_jj(["config", "set", "--repo", "user.email", "'Foo'"]);
|
||
insta::assert_snapshot!(output, @r#"
|
||
------- stderr -------
|
||
Warning: This setting will only impact future commits.
|
||
The author of the working copy will stay "Test User <test.user@example.com>".
|
||
To change the working copy author, use "jj describe --reset-author --no-edit"
|
||
[EOF]
|
||
"#);
|
||
|
||
// test_env.run_jj*() resets state for every invocation
|
||
// for this test, the state (user.email) is needed
|
||
work_dir
|
||
.run_jj_with(|cmd| {
|
||
cmd.args(["describe", "--reset-author", "--no-edit"])
|
||
.env_remove("JJ_EMAIL")
|
||
})
|
||
.success();
|
||
|
||
let output = work_dir.run_jj(["log"]);
|
||
insta::assert_snapshot!(output, @r"
|
||
@ qpvuntsm Foo 2001-02-03 08:05:09 f64cf908
|
||
│ (empty) (no description set)
|
||
◆ zzzzzzzz root() 00000000
|
||
[EOF]
|
||
");
|
||
}
|
||
|
||
#[test]
|
||
fn test_config_author_change_warning_root_env() {
|
||
let test_env = TestEnvironment::default();
|
||
let output = test_env.run_jj_in(".", ["config", "set", "--user", "user.email", "'Foo'"]);
|
||
insta::assert_snapshot!(output, @"");
|
||
}
|
||
|
||
fn find_stdout_lines(keyname_pattern: &str, stdout: &str) -> String {
|
||
let key_line_re = Regex::new(&format!(r"(?m)^{keyname_pattern} = .*\n")).unwrap();
|
||
key_line_re.find_iter(stdout).map(|m| m.as_str()).collect()
|
||
}
|