test: update end-to-end test to use README's example

Author: AnsonH

README.md

@@ -4,7 +4,7 @@ Neovim plugin to copy the reference path of a Python symbol.
 
 TODO(Anson): Add video
 
-## Features
+# Features
 
 - Supports copying different path formats (see [examples](#path-format-examples)):
   - Dotted path (e.g. `some.module.func_1`)
@@ -14,7 +14,7 @@ TODO(Anson): Add video
 - Allow copy to user-specified register
 - No LSP setup required
 
-## Installation
+# Installation
 
 Requires Neovim >=0.7.0.
 
@@ -32,7 +32,7 @@ With [wbthomason/packer.nvim](https://github.com/wbthomason/packer.nvim):
 use {"AnsonH/copy-python-path.nvim", tag = "*" }
 ```
 
-## Getting started
+# Getting started
 
 Open a Python file and place the cursor on the following supported symbols:
 
@@ -47,14 +47,14 @@ Then, run the command `:CopyPythonPath <format>` to copy to clipboard:
 - `:CopyPythonPath dotted` - Copies the dotted path (e.g. `some.module.func_1`)
 - `:CopyPythonPath import` - Copies the import path (e.g. `from some.module import func_1`)
 
-### Path format examples
+## Path format examples
 
 Let's say we have a file called `app.py`:
 
 ```py
 """ app.py """
 import numpy as np
-from some.module import foo
+from user.models import User
 
 # (1) 👇
 def func_1():
@@ -73,32 +73,32 @@ class MyClass:
     # (5) 👇
     def method_1(self):
         # (6) 👇
-        foo()
+        User()
         #  (7) 👇
         return np.array([])
 
 # (8) 👇
 MODULE_VAR = 'foo'
 ```
 
-| Cursor Location                | `:CopyPythonPath dotted` | `:CopyPythonPath import`       |
-| ------------------------------ | ------------------------ | ------------------------------ |
-| (1) Function definition        | `app.func_1`             | `from app import func_1`       |
-| (2) Async function definition  | `app.func_2`             | `from app import func_2`       |
-| (3) Class definition           | `app.MyClass`            | `from app import MyClass`      |
-| (4) Inner class                | `app.MyClass.Meta`       | `from app import MyClass`¹     |
-| (5) Class method               | `app.MyClass.method_1`   | `from app import MyClass`¹     |
-| (6) Imported symbol            | `some.module.foo`        | `from some.module import foo`² |
-| (7) Imported symbol with alias | `numpy`                  | `import numpy`                 |
-| (8) Module-level variable      | `app.MODULE_VAR`         | `from app import MODULE_VAR`   |
-| Elsewhere in the file          | `app`                    | `from app import `             |
+| Cursor Location                | `:CopyPythonPath dotted` | `:CopyPythonPath import`        |
+| ------------------------------ | ------------------------ | ------------------------------- |
+| (1) Function definition        | `app.func_1`             | `from app import func_1`        |
+| (2) Async function definition  | `app.func_2`             | `from app import func_2`        |
+| (3) Class definition           | `app.MyClass`            | `from app import MyClass`       |
+| (4) Inner class                | `app.MyClass.Meta`       | `from app import MyClass`¹      |
+| (5) Class method               | `app.MyClass.method_1`   | `from app import MyClass`¹      |
+| (6) Imported symbol            | `user.models.User`       | `from user.models import User`² |
+| (7) Imported symbol with alias | `numpy`                  | `import numpy`                  |
+| (8) Module-level variable      | `app.MODULE_VAR`         | `from app import MODULE_VAR`    |
+| Elsewhere in the file          | `app`                    | `from app import `              |
 
 Notes:
 
 1. Inner classes and class methods cannot be directly imported, so it only imports the outer class.
 2. When the symbol is imported, it copies the original path of where it was imported from.
 
-### Custom keymappings
+## Custom keymappings
 
 This plugin does NOT set up any keymappings by default. You can define custom keymappings in your Neovim config, for example:
 
@@ -107,7 +107,7 @@ vim.api.nvim_set_keymap('n', '<Leader>yd', ':CopyPythonPath dotted<CR>', { norem
 vim.api.nvim_set_keymap('n', '<Leader>yi', ':CopyPythonPath import<CR>', { noremap = true, silent = true })
 ```
 
-## Command
+# Command
 
 ```
 :CopyPythonPath <format> [<register>]
@@ -120,14 +120,27 @@ Copies the reference path of the Python symbol under the cursor.
 | `format`   | The path format to copy            | `dotted`, `import`      | N.A. (required) |
 | `register` | (optional) The register to copy to | Any valid register name | `+` (clipboard) |
 
-## API
+# API
 
 The plugin API is available via:
 
 ```lua
 local copy_python_path = require('copy-python-path')
 ```
 
+## `get_path_under_cursor`
+
+Gets the Python path of the symbol underneath the cursor.
+
+```lua
+--- Gets the Python path of the symbol underneath the cursor.
+---@param format string The Python path format. Accepted values are:
+---  - `"dotted"`: Dotted path (e.g. `user.models.User`)
+---  - `"import"`: Import statement (e.g. `from user.models import User`)
+---@return string path
+copy_python_path.get_path_under_cursor(format)
+```
+
 Example: Copy the shell command for running a Django test:
 
 ```lua
@@ -142,7 +155,7 @@ vim.api.nvim_create_user_command("CopyDjangoTestCommand", function(opts)
 end, {})
 ```
 
-## Similar Work
+# Similar Work
 
 - [kawamataryo/copy-python-path](https://github.com/kawamataryo/copy-python-path) - VS Code plugin that inspired this project
 - [ranelpadon/python-copy-reference.vim](https://github.com/ranelpadon/python-copy-reference.vim) - Vim Script plugin with similar functionality

tests/fixtures/app.py

@@ -0,0 +1,22 @@
+import numpy as np
+from user.models import User
+
+
+def func_1():
+    pass
+
+
+async def func_2():
+    pass
+
+
+class MyClass:
+    class Meta:
+        pass
+
+    def method_1(self):
+        User()
+        return np.array([])
+
+
+MODULE_VAR = "foo"

tests/fixtures/layer_one/layer_two/services.py

@@ -0,0 +1,6 @@
+from attrs import define
+
+
+@define
+class User:
+    id: str

tests/fixtures/root.py

@@ -15,8 +15,8 @@ local T = MiniTest.new_set({
     },
 })
 
-local EDIT_ROOT_FILE_COMMAND = "edit tests/fixtures/root.py"
-local EDIT_NESTED_FILE_COMMAND = "edit tests/fixtures/layer_one/layer_two/services.py"
+local EDIT_ROOT_FILE_COMMAND = "edit tests/fixtures/app.py"
+local EDIT_NESTED_FILE_COMMAND = "edit tests/fixtures/user/models.py"
 
 ---@param command string Full command to execute
 ---@param register string Register to check
@@ -40,16 +40,15 @@ T[":CopyPythonPath"]["dotted"] = MiniTest.new_set()
 T[":CopyPythonPath"]["dotted"]["root level Python file"] = function()
     child.api.nvim_command(EDIT_ROOT_FILE_COMMAND)
     local test_cases = {
-        -- Importable symbols
-        { { 5, 5 }, "root.func" },
-        { { 9, 16 }, "root.async_func" },
-        { { 13, 7 }, "root.OuterClass" },
-        { { 18, 13 }, "root.OuterClass.InnerClass.inner_class_method" },
-        { { 22, 10 }, "root.MODULE_LEVEL_CONSTANT" },
-        { { 15, 16 }, "numpy" },
-        { { 6, 5 }, "layer_one.layer_two.services.some_service" },
-        -- Non-importable symbol
-        { { 15, 26 }, "root" },
+        { { 5, 5 }, "app.func_1" },
+        { { 9, 11 }, "app.func_2" },
+        { { 13, 9 }, "app.MyClass" },
+        { { 14, 11 }, "app.MyClass.Meta" },
+        { { 17, 9 }, "app.MyClass.method_1" },
+        { { 18, 9 }, "user.models.User" },
+        { { 19, 16 }, "numpy" },
+        { { 22, 1 }, "app.MODULE_VAR" },
+        { { 6, 5 }, "app" }, -- non-importable symbol
     }
     run_test_cases("CopyPythonPath dotted a", "a", test_cases)
 end
@@ -58,10 +57,10 @@ T[":CopyPythonPath"]["dotted"]["nested Python file"] = function()
     child.api.nvim_command(EDIT_NESTED_FILE_COMMAND)
     local test_cases = {
         -- Importable symbols
-        { { 4, 5 }, "layer_one.layer_two.services.some_service" },
-        { { 5, 12 }, "numpy" },
+        { { 5, 7 }, "user.models.User" },
+        { { 4, 4 }, "attrs.define" },
         -- Non-importable symbol
-        { { 5, 21 }, "layer_one.layer_two.services" },
+        { { 6, 9 }, "user.models" },
     }
     run_test_cases("CopyPythonPath dotted a", "a", test_cases)
 end
@@ -71,16 +70,15 @@ T[":CopyPythonPath"]["import"] = MiniTest.new_set()
 T[":CopyPythonPath"]["import"]["root level Python file"] = function()
     child.api.nvim_command(EDIT_ROOT_FILE_COMMAND)
     local test_cases = {
-        -- Importable symbols
-        { { 5, 5 }, "from root import func" },
-        { { 9, 16 }, "from root import async_func" },
-        { { 13, 7 }, "from root import OuterClass" },
-        { { 18, 13 }, "from root import OuterClass" },
-        { { 22, 10 }, "from root import MODULE_LEVEL_CONSTANT" },
-        { { 15, 16 }, "import numpy" },
-        { { 6, 5 }, "from layer_one.layer_two.services import some_service" },
-        -- Non-importable symbol
-        { { 15, 26 }, "from root import " },
+        { { 5, 5 }, "from app import func_1" },
+        { { 9, 11 }, "from app import func_2" },
+        { { 13, 9 }, "from app import MyClass" },
+        { { 14, 11 }, "from app import MyClass" }, -- MyClass.Meta
+        { { 17, 9 }, "from app import MyClass" }, -- MyClass.method_1
+        { { 18, 9 }, "from user.models import User" },
+        { { 19, 16 }, "import numpy" },
+        { { 22, 1 }, "from app import MODULE_VAR" },
+        { { 6, 5 }, "from app import " }, -- non-importable symbol
     }
     run_test_cases("CopyPythonPath import a", "a", test_cases)
 end
@@ -89,10 +87,10 @@ T[":CopyPythonPath"]["import"]["nested Python file"] = function()
     child.api.nvim_command(EDIT_NESTED_FILE_COMMAND)
     local test_cases = {
         -- Importable symbols
-        { { 4, 5 }, "from layer_one.layer_two.services import some_service" },
-        { { 5, 12 }, "import numpy" },
+        { { 5, 7 }, "from user.models import User" },
+        { { 4, 4 }, "from attrs import define" },
         -- Non-importable symbol
-        { { 5, 21 }, "from layer_one.layer_two.services import " },
+        { { 6, 9 }, "from user.models import " },
     }
     run_test_cases("CopyPythonPath import a", "a", test_cases)
 end
@@ -104,7 +102,7 @@ T[":CopyPythonPath"]["copies to clipboard if no register is provided"] = functio
     child.api.nvim_command("CopyPythonPath dotted")
 
     local dotted_path = child.fn.getreg("+")
-    expect.equality(dotted_path, "root.func")
+    expect.equality(dotted_path, "app.func_1")
 end
 
 return T