psinfo 0.1.0__tar.gz

psinfo-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dan Blore
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

psinfo-0.1.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: psinfo
+Version: 0.1.0
+Summary: Rich terminal process viewer
+License: MIT
+Project-URL: Homepage, https://github.com/dblore/psinfo
+Project-URL: Repository, https://github.com/dblore/psinfo
+Project-URL: Issues, https://github.com/dblore/psinfo/issues
+Keywords: process,ps,terminal,cli,rich
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.9
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# psinfo
+
+A rich terminal process viewer. Search, filter, and watch running processes with colour-coded output.
+
+psinfo is for when you have a specific question — "what's on port 8080", "how much memory is Chrome using across all its helpers", "is nginx running and what's it doing" — and want a clean answer without launching a full process manager or constructing a `ps aux | grep | awk` pipeline.
+
+## Install
+
+```bash
+pip install -e .
+# or, to install as an isolated CLI tool:
+pipx install .
+```
+
+`pipx` is recommended for CLI tools — it installs into an isolated environment and puts `psinfo` on your PATH. Install it with `brew install pipx` or `pip install pipx`.
+
+## Usage
+
+```
+psinfo <name>            search by process name or command
+psinfo -u <username>     all processes owned by a user
+psinfo -p <port>         process listening on a port
+psinfo -P <pid>          single process by PID
+```
+
+### Flags
+
+| Flag | Short | Description |
+|---|---|---|
+| `--watch [N]` | `-w` | Live refresh every N seconds (default: 2) |
+| `--sort cpu\|mem` | `-s` | Sort order (default: cpu) |
+| `--tree` | `-t` | Group results by process tree hierarchy |
+
+Flags compose freely:
+
+```bash
+psinfo nginx -w
+psinfo python -w 5 -s mem
+psinfo slack -t -w
+```
+
+## Output
+
+### Card view (default)
+
+Each matching process is shown as a panel. The highest-CPU process gets a green border. Metrics are colour-coded: green (< 10%), orange (≥ 10%), red (≥ 50%).
+
+![Card view](https://raw.githubusercontent.com/dblore/psinfo/main/assets/card-view.svg)
+
+### Tree view (`-t`)
+
+Results are grouped by parent/child relationships. Parent nodes show their own CPU plus a `∑` total across the whole subtree.
+
+![Tree view](https://raw.githubusercontent.com/dblore/psinfo/main/assets/tree-view.svg)
+
+## Requirements
+
+- Python 3.9+
+- psutil >= 5.9
+- rich >= 13.0
+
+## Platform support
+
+| Platform | Status | Notes |
+|---|---|---|
+| macOS | ✓ | `--port` requires `sudo` |
+| Linux | ✓ | |
+| Windows | ✓ | Shows handles instead of file descriptors |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

psinfo-0.1.0/README.md

@@ -0,0 +1,72 @@
+# psinfo
+
+A rich terminal process viewer. Search, filter, and watch running processes with colour-coded output.
+
+psinfo is for when you have a specific question — "what's on port 8080", "how much memory is Chrome using across all its helpers", "is nginx running and what's it doing" — and want a clean answer without launching a full process manager or constructing a `ps aux | grep | awk` pipeline.
+
+## Install
+
+```bash
+pip install -e .
+# or, to install as an isolated CLI tool:
+pipx install .
+```
+
+`pipx` is recommended for CLI tools — it installs into an isolated environment and puts `psinfo` on your PATH. Install it with `brew install pipx` or `pip install pipx`.
+
+## Usage
+
+```
+psinfo <name>            search by process name or command
+psinfo -u <username>     all processes owned by a user
+psinfo -p <port>         process listening on a port
+psinfo -P <pid>          single process by PID
+```
+
+### Flags
+
+| Flag | Short | Description |
+|---|---|---|
+| `--watch [N]` | `-w` | Live refresh every N seconds (default: 2) |
+| `--sort cpu\|mem` | `-s` | Sort order (default: cpu) |
+| `--tree` | `-t` | Group results by process tree hierarchy |
+
+Flags compose freely:
+
+```bash
+psinfo nginx -w
+psinfo python -w 5 -s mem
+psinfo slack -t -w
+```
+
+## Output
+
+### Card view (default)
+
+Each matching process is shown as a panel. The highest-CPU process gets a green border. Metrics are colour-coded: green (< 10%), orange (≥ 10%), red (≥ 50%).
+
+![Card view](https://raw.githubusercontent.com/dblore/psinfo/main/assets/card-view.svg)
+
+### Tree view (`-t`)
+
+Results are grouped by parent/child relationships. Parent nodes show their own CPU plus a `∑` total across the whole subtree.
+
+![Tree view](https://raw.githubusercontent.com/dblore/psinfo/main/assets/tree-view.svg)
+
+## Requirements
+
+- Python 3.9+
+- psutil >= 5.9
+- rich >= 13.0
+
+## Platform support
+
+| Platform | Status | Notes |
+|---|---|---|
+| macOS | ✓ | `--port` requires `sudo` |
+| Linux | ✓ | |
+| Windows | ✓ | Shows handles instead of file descriptors |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

psinfo-0.1.0/psinfo.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: psinfo
+Version: 0.1.0
+Summary: Rich terminal process viewer
+License: MIT
+Project-URL: Homepage, https://github.com/dblore/psinfo
+Project-URL: Repository, https://github.com/dblore/psinfo
+Project-URL: Issues, https://github.com/dblore/psinfo/issues
+Keywords: process,ps,terminal,cli,rich
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: psutil>=5.9
+Requires-Dist: rich>=13.0
+Dynamic: license-file
+
+# psinfo
+
+A rich terminal process viewer. Search, filter, and watch running processes with colour-coded output.
+
+psinfo is for when you have a specific question — "what's on port 8080", "how much memory is Chrome using across all its helpers", "is nginx running and what's it doing" — and want a clean answer without launching a full process manager or constructing a `ps aux | grep | awk` pipeline.
+
+## Install
+
+```bash
+pip install -e .
+# or, to install as an isolated CLI tool:
+pipx install .
+```
+
+`pipx` is recommended for CLI tools — it installs into an isolated environment and puts `psinfo` on your PATH. Install it with `brew install pipx` or `pip install pipx`.
+
+## Usage
+
+```
+psinfo <name>            search by process name or command
+psinfo -u <username>     all processes owned by a user
+psinfo -p <port>         process listening on a port
+psinfo -P <pid>          single process by PID
+```
+
+### Flags
+
+| Flag | Short | Description |
+|---|---|---|
+| `--watch [N]` | `-w` | Live refresh every N seconds (default: 2) |
+| `--sort cpu\|mem` | `-s` | Sort order (default: cpu) |
+| `--tree` | `-t` | Group results by process tree hierarchy |
+
+Flags compose freely:
+
+```bash
+psinfo nginx -w
+psinfo python -w 5 -s mem
+psinfo slack -t -w
+```
+
+## Output
+
+### Card view (default)
+
+Each matching process is shown as a panel. The highest-CPU process gets a green border. Metrics are colour-coded: green (< 10%), orange (≥ 10%), red (≥ 50%).
+
+![Card view](https://raw.githubusercontent.com/dblore/psinfo/main/assets/card-view.svg)
+
+### Tree view (`-t`)
+
+Results are grouped by parent/child relationships. Parent nodes show their own CPU plus a `∑` total across the whole subtree.
+
+![Tree view](https://raw.githubusercontent.com/dblore/psinfo/main/assets/tree-view.svg)
+
+## Requirements
+
+- Python 3.9+
+- psutil >= 5.9
+- rich >= 13.0
+
+## Platform support
+
+| Platform | Status | Notes |
+|---|---|---|
+| macOS | ✓ | `--port` requires `sudo` |
+| Linux | ✓ | |
+| Windows | ✓ | Shows handles instead of file descriptors |
+
+## License
+
+MIT — see [LICENSE](LICENSE).

psinfo-0.1.0/psinfo.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+psinfo.egg-info/PKG-INFO
+psinfo.egg-info/SOURCES.txt
+psinfo.egg-info/dependency_links.txt
+psinfo.egg-info/entry_points.txt
+psinfo.egg-info/requires.txt
+psinfo.egg-info/top_level.txt
+tests/test_cli.py
+tests/test_query.py
+tests/test_render.py

psinfo-0.1.0/psinfo.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

psinfo-0.1.0/psinfo.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+psinfo = psinfo:main

psinfo-0.1.0/psinfo.egg-info/requires.txt

@@ -0,0 +1,2 @@
+psutil>=5.9
+rich>=13.0

psinfo-0.1.0/psinfo.egg-info/top_level.txt

@@ -0,0 +1 @@
+assets

psinfo-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "psinfo"
+version = "0.1.0"
+description = "Rich terminal process viewer"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+keywords = ["process", "ps", "terminal", "cli", "rich"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: System Administrators",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: MacOS",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: Microsoft :: Windows",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Monitoring",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "psutil>=5.9",
+    "rich>=13.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/dblore/psinfo"
+Repository = "https://github.com/dblore/psinfo"
+Issues = "https://github.com/dblore/psinfo/issues"
+
+[project.scripts]
+psinfo = "psinfo:main"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

psinfo-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

psinfo-0.1.0/tests/test_cli.py

@@ -0,0 +1,99 @@
+import sys
+import pytest
+from unittest.mock import patch, MagicMock
+from psinfo import ProcessInfo
+
+
+def test_parser_accepts_name_positional():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["mysql"])
+    assert args.name == "mysql"
+
+
+def test_parser_accepts_user_flag():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["--user", "root"])
+    assert args.user == "root"
+
+
+def test_parser_accepts_port_flag():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["--port", "3306"])
+    assert args.port == 3306
+
+
+def test_parser_accepts_pid_flag():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["--pid", "1234"])
+    assert args.pid == 1234
+
+
+def test_parser_watch_defaults_to_2():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["mysql", "--watch"])
+    assert args.watch == 2.0
+
+
+def test_parser_watch_accepts_custom_interval():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["mysql", "--watch", "5"])
+    assert args.watch == 5.0
+
+
+def test_parser_sort_defaults_to_cpu():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["mysql"])
+    assert args.sort == "cpu"
+
+
+def test_parser_sort_accepts_mem():
+    from psinfo import build_parser
+    args = build_parser().parse_args(["mysql", "--sort", "mem"])
+    assert args.sort == "mem"
+
+
+def test_main_calls_find_by_name(mocker):
+    from psinfo import main
+    mock_find = mocker.patch("psinfo.find_by_name", return_value=[])
+    mocker.patch("psutil.net_connections", return_value=[])
+    with patch("sys.argv", ["psinfo", "mysql"]):
+        main()
+    mock_find.assert_called_once_with("mysql")
+
+
+def test_main_calls_find_by_user(mocker):
+    from psinfo import main
+    mock_find = mocker.patch("psinfo.find_by_user", return_value=[])
+    with patch("sys.argv", ["psinfo", "--user", "root"]):
+        main()
+    mock_find.assert_called_once_with("root")
+
+
+def test_main_calls_find_by_pid(mocker):
+    from psinfo import main
+    proc = ProcessInfo(
+        pid=1234, name="test", cmdline=[], username="user",
+        cpu_percent=0.0, mem_percent=0.0, rss_mb=0.0,
+        num_threads=1, create_time=0.0, num_fds=0
+    )
+    mock_find = mocker.patch("psinfo.find_by_pid", return_value=proc)
+    with patch("sys.argv", ["psinfo", "--pid", "1234"]):
+        main()
+    mock_find.assert_called_once_with(1234)
+
+
+def test_main_calls_find_by_port(mocker):
+    from psinfo import main
+    mock_find = mocker.patch("psinfo.find_by_port", return_value=None)
+    with patch("sys.argv", ["psinfo", "--port", "3306"]):
+        main()
+    mock_find.assert_called_once_with(3306)
+
+
+def test_main_exits_1_when_pid_not_found(mocker):
+    from psinfo import main
+    mocker.patch("psinfo.find_by_pid", return_value=None)
+    with patch("sys.argv", ["psinfo", "--pid", "9999"]):
+        with pytest.raises(SystemExit) as exc:
+            main()
+    assert exc.value.code == 1

psinfo-0.1.0/tests/test_query.py

@@ -0,0 +1,261 @@
+from unittest.mock import MagicMock
+
+
+def make_mock_proc(
+    pid=1234,
+    name="mysqld",
+    cmdline=None,
+    username="mysql",
+    cpu_percent=0.5,
+    memory_percent=2.1,
+    rss=176160768,  # bytes → 168 MB
+    num_threads=32,
+    create_time=1000000.0,
+    num_fds=48,
+):
+    if cmdline is None:
+        cmdline = ["/usr/sbin/mysqld", "--datadir=/var/lib/mysql"]
+    proc = MagicMock()
+    mem_info = MagicMock()
+    mem_info.rss = rss
+    proc.info = {
+        "pid": pid,
+        "name": name,
+        "cmdline": cmdline,
+        "username": username,
+        "cpu_percent": cpu_percent,
+        "memory_percent": memory_percent,
+        "memory_info": mem_info,
+        "num_threads": num_threads,
+        "create_time": create_time,
+        "num_fds": num_fds,
+    }
+    proc.as_dict.return_value = dict(proc.info)
+    return proc
+
+
+def test_process_info_fields():
+    from psinfo import ProcessInfo
+    p = ProcessInfo(
+        pid=1234,
+        name="mysqld",
+        cmdline=["/usr/sbin/mysqld", "--datadir=/var/lib/mysql"],
+        username="mysql",
+        cpu_percent=0.5,
+        mem_percent=2.1,
+        rss_mb=168.0,
+        num_threads=32,
+        create_time=1000000.0,
+        num_fds=48,
+    )
+    assert p.pid == 1234
+    assert p.name == "mysqld"
+    assert p.rss_mb == 168.0
+
+
+def test_command_joins_cmdline():
+    from psinfo import ProcessInfo
+    p = ProcessInfo(
+        pid=1, name="mysqld",
+        cmdline=["/usr/sbin/mysqld", "--datadir=/var/lib/mysql"],
+        username="mysql", cpu_percent=0.0, mem_percent=0.0,
+        rss_mb=0.0, num_threads=1, create_time=1000000.0, num_fds=0,
+    )
+    assert p.command == "/usr/sbin/mysqld --datadir=/var/lib/mysql"
+
+
+def test_command_falls_back_to_name_when_no_cmdline():
+    from psinfo import ProcessInfo
+    p = ProcessInfo(
+        pid=1, name="kernel_task", cmdline=[],
+        username="root", cpu_percent=0.0, mem_percent=0.0,
+        rss_mb=0.0, num_threads=1, create_time=1000000.0, num_fds=0,
+    )
+    assert p.command == "kernel_task"
+
+
+def test_proc_to_info_converts_mock():
+    from psinfo import _proc_to_info
+    mock = make_mock_proc()
+    result = _proc_to_info(mock)
+    assert result is not None
+    assert result.pid == 1234
+    assert result.name == "mysqld"
+    assert abs(result.rss_mb - 168.0) < 1.0
+    assert result.num_threads == 32
+
+
+def test_proc_to_info_returns_none_on_no_such_process():
+    import psutil
+    from psinfo import _proc_to_info
+    mock = MagicMock()
+    mock.as_dict.side_effect = psutil.NoSuchProcess(pid=9999)
+    assert _proc_to_info(mock) is None
+
+
+def test_proc_to_info_returns_none_on_access_denied():
+    import psutil
+    from psinfo import _proc_to_info
+    mock = MagicMock()
+    mock.as_dict.side_effect = psutil.AccessDenied(pid=1)
+    assert _proc_to_info(mock) is None
+
+
+def test_find_by_name_matches_name_field(mocker):
+    from psinfo import find_by_name
+    mock_mysql = make_mock_proc(name="mysqld", cmdline=["/usr/sbin/mysqld"])
+    mock_other = make_mock_proc(pid=9999, name="nginx", cmdline=["/usr/sbin/nginx"])
+    mocker.patch("psutil.process_iter", return_value=[mock_mysql, mock_other])
+    results = find_by_name("mysql")
+    assert len(results) == 1
+    assert results[0].name == "mysqld"
+
+
+def test_find_by_name_matches_cmdline(mocker):
+    from psinfo import find_by_name
+    mock = make_mock_proc(name="python3", cmdline=["python3", "manage.py", "runserver"])
+    mocker.patch("psutil.process_iter", return_value=[mock])
+    results = find_by_name("manage")
+    assert len(results) == 1
+
+
+def test_find_by_name_is_case_insensitive(mocker):
+    from psinfo import find_by_name
+    mock = make_mock_proc(name="MySQLd")
+    mocker.patch("psutil.process_iter", return_value=[mock])
+    results = find_by_name("mysql")
+    assert len(results) == 1
+
+
+def test_find_by_name_returns_empty_when_no_match(mocker):
+    from psinfo import find_by_name
+    mock = make_mock_proc(name="nginx", cmdline=["/usr/sbin/nginx"])
+    mocker.patch("psutil.process_iter", return_value=[mock])
+    results = find_by_name("mysql")
+    assert results == []
+
+
+def test_find_by_name_skips_inaccessible_processes(mocker):
+    import psutil
+    from psinfo import find_by_name
+    bad_proc = MagicMock()
+    bad_proc.info = MagicMock()
+    bad_proc.info.get = MagicMock(side_effect=psutil.AccessDenied(pid=1))
+    good = make_mock_proc(name="mysqld")
+    mocker.patch("psutil.process_iter", return_value=[bad_proc, good])
+    results = find_by_name("mysql")
+    assert len(results) == 1
+
+
+def test_find_by_user_filters_by_username(mocker):
+    from psinfo import find_by_user
+    mysql_proc = make_mock_proc(pid=1234, name="mysqld", username="mysql")
+    root_proc = make_mock_proc(pid=1235, name="sshd", username="root")
+    mocker.patch("psutil.process_iter", return_value=[mysql_proc, root_proc])
+    results = find_by_user("mysql")
+    assert len(results) == 1
+    assert results[0].username == "mysql"
+
+
+def test_find_by_user_is_case_insensitive(mocker):
+    from psinfo import find_by_user
+    proc = make_mock_proc(username="MySQL")
+    mocker.patch("psutil.process_iter", return_value=[proc])
+    results = find_by_user("mysql")
+    assert len(results) == 1
+
+
+def test_find_by_pid_returns_process(mocker):
+    from psinfo import find_by_pid
+    mock = make_mock_proc(pid=1234)
+    mocker.patch("psutil.Process", return_value=mock)
+    result = find_by_pid(1234)
+    assert result is not None
+    assert result.pid == 1234
+
+
+def test_find_by_pid_returns_none_when_not_found(mocker):
+    import psutil
+    from psinfo import find_by_pid
+    mocker.patch("psutil.Process", side_effect=psutil.NoSuchProcess(pid=9999))
+    assert find_by_pid(9999) is None
+
+
+def test_find_by_port_returns_process_owning_port(mocker):
+    from psinfo import find_by_port
+    conn = MagicMock()
+    conn.laddr.port = 3306
+    conn.pid = 1234
+    mocker.patch("psutil.net_connections", return_value=[conn])
+    mock_proc = make_mock_proc(pid=1234, name="mysqld")
+    mocker.patch("psutil.Process", return_value=mock_proc)
+    result = find_by_port(3306)
+    assert result is not None
+    assert result.pid == 1234
+
+
+def test_find_by_port_returns_none_when_port_not_in_use(mocker):
+    from psinfo import find_by_port
+    conn = MagicMock()
+    conn.laddr.port = 8080
+    conn.pid = 999
+    mocker.patch("psutil.net_connections", return_value=[conn])
+    result = find_by_port(3306)
+    assert result is None
+
+
+def test_find_by_port_returns_none_on_access_denied(mocker):
+    import psutil
+    from psinfo import find_by_port
+    mocker.patch("psutil.net_connections", side_effect=psutil.AccessDenied(pid=0))
+    assert find_by_port(3306) is None
+
+
+def test_find_by_pid_returns_none_on_access_denied(mocker):
+    import psutil
+    from psinfo import find_by_pid
+    mocker.patch("psutil.Process", side_effect=psutil.AccessDenied(pid=1))
+    assert find_by_pid(1) is None
+
+
+def test_find_by_port_prefers_listen_state(mocker):
+    from psinfo import find_by_port
+    listen_conn = MagicMock()
+    listen_conn.laddr.port = 3306
+    listen_conn.pid = 1234
+    listen_conn.status = "LISTEN"
+    estab_conn = MagicMock()
+    estab_conn.laddr.port = 3306
+    estab_conn.pid = 5678
+    estab_conn.status = "ESTABLISHED"
+    mocker.patch("psutil.net_connections", return_value=[estab_conn, listen_conn])
+    mock_proc = make_mock_proc(pid=1234, name="mysqld")
+    mocker.patch("psutil.Process", return_value=mock_proc)
+    result = find_by_port(3306)
+    assert result is not None
+    assert result.pid == 1234  # LISTEN connection preferred over ESTABLISHED
+
+
+def test_find_by_name_excludes_self(mocker):
+    import os
+    from psinfo import find_by_name
+    self_proc = make_mock_proc(pid=os.getpid(), name="python3",
+                               cmdline=["python3", "psinfo", "mysql"])
+    other_proc = make_mock_proc(pid=9999, name="mysqld", cmdline=["/usr/sbin/mysqld"])
+    mocker.patch("psutil.process_iter", return_value=[self_proc, other_proc])
+    results = find_by_name("mysql")
+    assert all(r.pid != os.getpid() for r in results)
+    assert len(results) == 1
+    assert results[0].pid == 9999
+
+
+def test_find_by_user_excludes_self(mocker):
+    import os
+    from psinfo import find_by_user
+    self_proc = make_mock_proc(pid=os.getpid(), name="python3", username="dan")
+    other_proc = make_mock_proc(pid=9999, name="bash", username="dan")
+    mocker.patch("psutil.process_iter", return_value=[self_proc, other_proc])
+    results = find_by_user("dan")
+    assert all(r.pid != os.getpid() for r in results)
+    assert len(results) == 1
+    assert results[0].pid == 9999

psinfo-0.1.0/tests/test_render.py

@@ -0,0 +1,177 @@
+import io
+import pytest
+from rich.console import Console
+from rich.panel import Panel
+
+
+def make_proc(cpu=0.5, mem=2.1, rss_mb=168.0, name="mysqld", pid=1234,
+              cmdline=None, username="mysql", num_threads=32, num_fds=48,
+              create_time=1000000.0):
+    if cmdline is None:
+        cmdline = ["/usr/sbin/mysqld", "--datadir=/var/lib/mysql"]
+    from psinfo import ProcessInfo
+    return ProcessInfo(
+        pid=pid, name=name, cmdline=cmdline, username=username,
+        cpu_percent=cpu, mem_percent=mem, rss_mb=rss_mb,
+        num_threads=num_threads, create_time=create_time, num_fds=num_fds,
+    )
+
+
+def render_to_str(renderable) -> str:
+    buf = io.StringIO()
+    console = Console(file=buf, width=100, highlight=False, markup=False)
+    console.print(renderable)
+    return buf.getvalue()
+
+
+def test_render_card_returns_panel():
+    from psinfo import render_card
+    proc = make_proc()
+    card = render_card(proc, highlight=False)
+    assert isinstance(card, Panel)
+
+
+def test_render_card_contains_pid():
+    from psinfo import render_card
+    proc = make_proc(pid=1234)
+    output = render_to_str(render_card(proc))
+    assert "1234" in output
+
+
+def test_render_card_contains_process_name():
+    from psinfo import render_card
+    proc = make_proc(name="mysqld")
+    output = render_to_str(render_card(proc))
+    assert "mysqld" in output
+
+
+def test_render_card_contains_username():
+    from psinfo import render_card
+    proc = make_proc(username="mysql")
+    output = render_to_str(render_card(proc))
+    assert "mysql" in output
+
+
+def test_render_card_contains_rss():
+    from psinfo import render_card
+    proc = make_proc(rss_mb=168.0)
+    output = render_to_str(render_card(proc))
+    assert "168" in output
+
+
+def test_render_card_contains_thread_count():
+    from psinfo import render_card
+    proc = make_proc(num_threads=32)
+    output = render_to_str(render_card(proc))
+    assert "32" in output
+
+
+def test_metric_color_green_below_10():
+    from psinfo import _metric_color
+    assert _metric_color(5.0) == "green"
+
+
+def test_metric_color_orange_between_10_and_50():
+    from psinfo import _metric_color
+    assert _metric_color(25.0) == "dark_orange"
+
+
+def test_metric_color_red_above_50():
+    from psinfo import _metric_color
+    assert _metric_color(75.0) == "red"
+
+
+def test_render_card_contains_cpu():
+    from psinfo import render_card
+    proc = make_proc(cpu=42.5)
+    output = render_to_str(render_card(proc))
+    assert "42.5" in output
+
+
+def test_render_card_contains_mem():
+    from psinfo import render_card
+    proc = make_proc(mem=3.7)
+    output = render_to_str(render_card(proc))
+    assert "3.7" in output
+
+
+def test_render_card_contains_fd_count():
+    from psinfo import render_card
+    proc = make_proc(num_fds=99)
+    output = render_to_str(render_card(proc))
+    assert "99" in output
+
+
+def test_render_card_contains_command():
+    from psinfo import render_card
+    proc = make_proc(cmdline=["/usr/sbin/mysqld", "--datadir=/var/lib/mysql"])
+    output = render_to_str(render_card(proc))
+    assert "/usr/sbin/mysqld" in output
+
+
+def test_render_card_highlight_uses_green_title():
+    from psinfo import render_card
+    from rich.panel import Panel
+    from rich.text import Text
+    proc = make_proc(name="mysqld")
+    highlighted_card = render_card(proc, highlight=True)
+    normal_card = render_card(proc, highlight=False)
+    # Highlighted card has green border, normal has dim
+    assert highlighted_card.border_style == "green"
+    assert normal_card.border_style == "dim"
+
+
+def test_metric_color_at_warn_boundary():
+    from psinfo import _metric_color
+    assert _metric_color(10.0) == "dark_orange"  # exactly at warn threshold
+
+
+def test_metric_color_at_critical_boundary():
+    from psinfo import _metric_color
+    assert _metric_color(50.0) == "red"  # exactly at critical threshold
+
+
+def test_render_results_shows_match_count():
+    from psinfo import render_results
+    procs = [make_proc(pid=1), make_proc(pid=2, name="mysqld_safe")]
+    output = render_to_str(render_results(procs, "mysql"))
+    assert "2" in output
+    assert "mysql" in output
+
+
+def test_render_results_shows_no_processes_when_empty():
+    from psinfo import render_results
+    output = render_to_str(render_results([], "mysql"))
+    assert "No processes found" in output
+
+
+def test_sort_procs_by_cpu_descending():
+    from psinfo import sort_procs
+    procs = [make_proc(cpu=1.0, pid=1), make_proc(cpu=5.0, pid=2), make_proc(cpu=0.5, pid=3)]
+    result = sort_procs(procs, "cpu")
+    assert result[0].cpu_percent == 5.0
+    assert result[-1].cpu_percent == 0.5
+
+
+def test_sort_procs_by_mem_descending():
+    from psinfo import sort_procs
+    procs = [make_proc(mem=1.0, pid=1), make_proc(mem=5.0, pid=2)]
+    result = sort_procs(procs, "mem")
+    assert result[0].mem_percent == 5.0
+
+
+def test_sort_procs_by_pid_ascending():
+    from psinfo import sort_procs
+    procs = [make_proc(pid=300), make_proc(pid=100), make_proc(pid=200)]
+    result = sort_procs(procs, "pid")
+    assert result[0].pid == 100
+    assert result[-1].pid == 300
+
+
+def test_render_results_highlights_highest_cpu():
+    from psinfo import render_results
+    high = make_proc(pid=1, cpu=50.0, name="high_cpu")
+    low = make_proc(pid=2, cpu=1.0, name="low_cpu")
+    output = render_to_str(render_results([high, low], "test"))
+    assert "high_cpu" in output
+    assert "low_cpu" in output