Files
nushell/tests/repl/test_cell_path.rs
Peng Lu 53b805c2c5 Inaccurate error message when using negative index in cell path (#18282)
This PR should close #18281

After applying this patch.
```
/content/nushell/target/release> [["A", "B"], ["1", "2"]] | get  0.-1
Error: nu::parser::error

  × Invalid literal
   ╭─[repl_entry #1:1:35]
 1 │ [["A", "B"], ["1", "2"]] | get  0.-1
   ·                                   ─┬
   ·                                    ╰── negative index is not supported in cell path
   ╰────
```

```
/content/nushell/target/release> [1, 2, 3] | reject (-1)
Error: nu::shell::cant_convert

  × Can't convert to cell path.
   ╭─[repl_entry #5:1:20]
 1 │ [1, 2, 3] | reject (-1)
   ·                    ──┬─
   ·                      ╰── can't convert negative number to cell path
   ╰────                                                                                                                                     
```

<!--
Thanks for contributing to Nushell!

Before submitting, please read the contributing guide:
https://github.com/nushell/nushell/blob/main/CONTRIBUTING.md

This template helps reviewers understand your changes and allows us to
generate high-quality release notes.
-->

## Description
<!--
Explain what this PR does and why.

This section is intentionally flexible:
- Describe the problem
- Explain your approach
- Include technical details if relevant

Good examples:
- "In this PR, I fixed..."
- "In this PR, I added support for..."
- "This change improves X by..."

Write as much or as little as needed for reviewers to understand your
changes.
-->

## User-facing changes (Release notes)
<!--
This section is used (mostly as-is) for https://www.nushell.sh/blog/

Describe how Nushell behavior changes from a user's perspective.
Do NOT describe internal Rust changes here.

Write in a release note style, for example:
- "Added support for..."
- "Fixed an issue where..."
- "Nushell now supports..."
- "Improved performance of..."

If your changes do NOT affect users (internal refactors, cleanup, etc.),
just write:
- "n/a"
- "nan"
- or similar

This tells us the change should not appear in the changelog.

Tips:
- Focus on observable behavior
- Include examples if helpful
- Keep it concise

You can:
- Write a short paragraph (will appear as a bullet point), OR
- Use headings (###) if your change needs more structure

Avoid writing things like:
- "In this PR, I refactored..."
- "This updates internal code..."

You may leave this blank until the PR is ready.
-->

## Additional notes
<!--
Optional.

Examples:
- fixes #123
- closes #456
- related #789

Anything else reviewers should know.
Remove this section if not needed.
-->
2026-06-01 11:13:09 -05:00

170 lines
4.3 KiB
Rust

use crate::repl::tests::{TestResult, fail_test, run_test};
// Tests for null / null / Value::Nothing
#[test]
fn nothing_fails_string() -> TestResult {
fail_test("let nil = null; $nil.foo", "doesn't support cell paths")
}
#[test]
fn nothing_fails_int() -> TestResult {
fail_test("let nil = null; $nil.3", "doesn't support cell paths")
}
// Tests for records
#[test]
fn record_single_field_success() -> TestResult {
run_test("{foo: 'bar'}.foo == 'bar'", "true")
}
#[test]
fn record_single_field_optional_success() -> TestResult {
run_test("{foo: 'bar'}.foo? == 'bar'", "true")
}
#[test]
fn empty_record_optional_field_is_null() -> TestResult {
run_test("{}.foo? | to nuon", "null")
}
#[test]
fn get_works_with_cell_path_success() -> TestResult {
run_test("{foo: 'bar'} | get foo?", "bar")
}
#[test]
fn get_works_with_cell_path_missing_data() -> TestResult {
run_test("{foo: 'bar'} | get foobar? | to nuon", "null")
}
#[test]
fn record_single_field_failure() -> TestResult {
fail_test("{foo: 'bar'}.foobar", "")
}
#[test]
fn record_int_failure() -> TestResult {
fail_test("{foo: 'bar'}.3", "")
}
#[test]
fn record_single_field_optional() -> TestResult {
run_test("{foo: 'bar'}.foobar? | to nuon", "null")
}
#[test]
fn record_single_field_optional_short_circuits() -> TestResult {
// Check that we return null as soon as the `.foobar?` access
// fails instead of erroring on the `.baz` access
run_test("{foo: 'bar'}.foobar?.baz | to nuon", "null")
}
#[test]
fn record_multiple_optional_fields() -> TestResult {
run_test("{foo: 'bar'}.foobar?.baz? | to nuon", "null")
}
#[test]
fn nested_record_field_success() -> TestResult {
run_test("{foo: {bar: 'baz'} }.foo.bar == 'baz'", "true")
}
#[test]
fn nested_record_field_failure() -> TestResult {
fail_test("{foo: {bar: 'baz'} }.foo.asdf", "")
}
#[test]
fn nested_record_field_optional() -> TestResult {
run_test("{foo: {bar: 'baz'} }.foo.asdf? | to nuon", "null")
}
#[test]
fn record_with_nested_list_success() -> TestResult {
run_test("{foo: [{bar: 'baz'}]}.foo.0.bar == 'baz'", "true")
}
#[test]
fn record_with_nested_list_int_failure() -> TestResult {
fail_test("{foo: [{bar: 'baz'}]}.foo.3.bar", "")
}
#[test]
fn record_with_nested_list_column_failure() -> TestResult {
fail_test("{foo: [{bar: 'baz'}]}.foo.0.asdf", "")
}
// Tests for lists
#[test]
fn list_single_field_success() -> TestResult {
run_test("[{foo: 'bar'}].foo.0 == 'bar'", "true")?;
// test field access both ways
run_test("[{foo: 'bar'}].0.foo == 'bar'", "true")
}
#[test]
fn list_single_field_failure() -> TestResult {
fail_test("[{foo: 'bar'}].asdf", "")
}
// Test the scenario where the requested column is not present in all rows
#[test]
fn jagged_list_access_fails() -> TestResult {
fail_test("[{foo: 'bar'}, {}].foo", "column 'foo' is missing")?;
fail_test("[{}, {foo: 'bar'}].foo", "column 'foo' is missing")
}
#[test]
fn jagged_list_optional_access_succeeds() -> TestResult {
run_test("[{foo: 'bar'}, {}].foo?.0", "bar")?;
run_test("[{foo: 'bar'}, {}].foo?.1 | to nuon", "null")?;
run_test("[{}, {foo: 'bar'}].foo?.0 | to nuon", "null")?;
run_test("[{}, {foo: 'bar'}].foo?.1", "bar")
}
// test that accessing a nonexistent row fails
#[test]
fn list_row_access_failure() -> TestResult {
fail_test("[{foo: 'bar'}, {foo: 'baz'}].2", "")
}
#[test]
fn list_negative_row_access_reports_clear_error() -> TestResult {
fail_test(
"[{foo: 'bar'}, {foo: 'baz'}].-1",
"negative index is not supported in cell path",
)
}
#[test]
fn list_row_optional_access_succeeds() -> TestResult {
run_test("[{foo: 'bar'}, {foo: 'baz'}].2? | to nuon", "null")?;
run_test("[{foo: 'bar'}, {foo: 'baz'}].3? | to nuon", "null")
}
// regression test for an old bug
#[test]
fn do_not_delve_too_deep_in_nested_lists() -> TestResult {
fail_test("[[{foo: bar}]].foo", "column 'foo' is missing")
}
#[test]
fn cell_path_literals() -> TestResult {
run_test("let cell_path = $.a.b; {a: {b: 3}} | get $cell_path", "3")
}
// Test whether cell path access short-circuits properly
#[test]
fn deeply_nested_cell_path_short_circuits() -> TestResult {
run_test(
"{foo: [{bar: 'baz'}]}.foo.3?.bar.asdfdafg.234.foobar | to nuon",
"null",
)
}
#[test]
fn cell_path_type() -> TestResult {
run_test("$.a.b | describe", "cell-path")
}