AI powered OSINT engine to discover and map 840+ social media identities across the web
Python aiartificial-intelligencedebainhackhackerhackinghackingtoolsinformationinformation-gatheringlinuxlinux-desktoposintpythonpython-scriptpython3social-mediasocialmediahackingtermuxtermux-tool
import json
import re
from pathlib import Path
from aliens_eye.cli import (
TOR_PROXY,
apply_cli_overrides,
apply_config,
apply_scan_profile,
build_parser,
load_config,
parse_formats,
parse_formats_value,
parse_site_list,
)
from aliens_eye.core.config import ScannerConfig
def parse(argv):
return build_parser().parse_args(argv)
def test_parse_formats():
assert parse_formats("json,csv") == ["json", "csv"]
assert parse_formats("ALL,json") == ["all"]
assert parse_formats("") == ["json"]
assert parse_formats_value(None) == ["json"]
assert parse_formats_value(["json", "md"]) == ["json", "md"]
def test_parse_site_list():
assert parse_site_list("github, reddit") == ["github", "reddit"]
assert parse_site_list(None) is None
assert parse_site_list(" , ") is None
def test_apply_config_overrides_fields():
config = ScannerConfig()
defaults = apply_config(
config,
{
"concurrent": 10,
"timeout": 3.5,
"output_dir": "out",
"level": "advanced",
"output_formats": ["csv"],
"proxy": "http://localhost:8080",
},
)
assert config.concurrent == 10
assert config.timeout == 3.5
assert config.output_dir == Path("out")
assert config.proxy == "http://localhost:8080"
assert defaults["level"] == "advanced"
assert defaults["output_formats"] == ["csv"]
def test_cli_overrides_beat_config():
config = ScannerConfig()
apply_config(config, {"concurrent": 10})
args = parse(["user", "-c", "99", "--tor", "--no-ml", "--no-nsfw", "--site", "github"])
apply_cli_overrides(config, args)
assert config.concurrent == 99
assert config.proxy == TOR_PROXY
assert config.use_ml is False
assert config.exclude_nsfw is True
assert config.include_sites == ["github"]
def test_proxy_flag():
config = ScannerConfig()
args = parse(["user", "--proxy", "socks5://127.0.0.1:1080"])
apply_cli_overrides(config, args)
assert config.proxy == "socks5://127.0.0.1:1080"
def test_scan_profile_quick():
config = ScannerConfig()
args = parse(["user"])
apply_scan_profile(config, "quick", args)
assert config.concurrent == 25
assert config.use_playwright is False
def test_scan_profile_respects_cli_args():
config = ScannerConfig()
args = parse(["user", "-c", "5"])
apply_cli_overrides(config, args)
apply_scan_profile(config, "aggressive", args)
assert config.concurrent == 5
assert config.use_playwright is True
def test_load_config_explicit_path(tmp_path, logger):
path = tmp_path / "config.json"
path.write_text(json.dumps({"concurrent": 7}), encoding="utf-8")
assert load_config(str(path), logger) == {"concurrent": 7}
def test_load_config_missing_returns_empty(tmp_path, logger):
assert load_config(str(tmp_path / "nope.json"), logger) == {}
def test_accept_encoding_only_advertises_decodable_encodings():
"""Advertising br without a decoder is a hard failure, not a degradation.
Regression: DEFAULT_HEADERS hardcoded "gzip, deflate, br" while Brotli was
not a dependency, so every server that honoured br returned a body aiohttp
raised on. That was 852 of 978 capture errors across a 428-site run, with
173 sites failing completely.
"""
from aliens_eye.core.config import DEFAULT_HEADERS
encodings = {e.strip() for e in DEFAULT_HEADERS["Accept-Encoding"].split(",")}
assert "gzip" in encodings and "deflate" in encodings
try:
import brotli # noqa: F401
decoder = True
except ImportError:
try:
import brotlicffi # noqa: F401
decoder = True
except ImportError:
decoder = False
assert ("br" in encodings) == decoder, (
"Accept-Encoding advertises br without an importable Brotli decoder"
if not decoder else
"Brotli is installed but br is not advertised"
)
def _pyproject_text() -> str:
return (Path(__file__).resolve().parents[1] / "pyproject.toml").read_text(
encoding="utf-8"
)
def _declared_dependencies() -> list[str]:
"""Requirement strings from [project].dependencies.
Parsed with a regex rather than tomllib: tomllib is 3.11+, and this project
supports 3.10. Only the quoted requirements are returned, so a comment
mentioning a package name inside the array does not count as declaring it.
"""
block = re.search(r"^dependencies\s*=\s*\[(.*?)^\]", _pyproject_text(), re.M | re.S)
assert block, "could not locate [project].dependencies in pyproject.toml"
return [match.lower() for match in re.findall(r'"([^"]+)"', block.group(1))]
def _declared_version() -> str:
match = re.search(r'^version\s*=\s*"([^"]+)"', _pyproject_text(), re.M)
assert match, "could not locate [project].version in pyproject.toml"
return match.group(1)
def test_brotli_is_a_declared_dependency():
"""It is required, not an extra: the default headers depend on it."""
assert any(dep.startswith("brotli") for dep in _declared_dependencies())
def test_package_version_matches_pyproject():
"""__version__ and pyproject must agree.
Regression: 2.2.3 was built with pyproject bumped but
src/aliens_eye/__init__.py left at 2.2.2, so the installed package reported
the previous version. __version__ is what `--version` prints and what the
corpus manifest records as tool_version, so a stale value silently
mislabels captured research data.
"""
from aliens_eye import __version__
assert __version__ == _declared_version()
def test_selectolax_has_an_upper_bound():
"""Regression: with an unbounded ``selectolax>=0.3.21`` every fresh install
broke the day selectolax 1.0 removed the backend this package imported."""
[requirement] = [dep for dep in _declared_dependencies() if dep.startswith("selectolax")]
assert "<" in requirement
def test_analyzer_uses_a_parser_backend_that_still_exists():
"""The Modest backend (selectolax.parser) is gone in 1.0; Lexbor is in both."""
import aliens_eye.core.analyzer as analyzer
assert analyzer.HTMLParser.__module__.startswith("selectolax.lexbor")
def test_control_check_is_on_by_default_and_can_be_turned_off():
from aliens_eye.cli import apply_cli_overrides, build_parser
from aliens_eye.core.config import ScannerConfig
config = ScannerConfig()
assert config.control_check is True
apply_cli_overrides(config, build_parser().parse_args(["someone"]))
assert config.control_check is True
apply_cli_overrides(config, build_parser().parse_args(["someone", "--no-control-check"]))
assert config.control_check is False
# --- warning before an expensive scan level (#26) ---------------------------------------
def test_scan_cost_is_requests_and_a_rough_time():
from aliens_eye.core.variations import scan_cost
cost = scan_cost(variations=123, sites=854)
assert cost.requests == 105_042
assert 90 <= cost.minutes <= 130 # about 16 sites a second at the default concurrency
assert scan_cost(variations=1, sites=854).requests == 854
def test_cost_wording_is_in_hours_for_long_scans():
from aliens_eye.core.variations import scan_cost
assert "hour" in scan_cost(123, 854).describe()
assert "minute" in scan_cost(1, 854).describe()
assert "105,042" in scan_cost(123, 854).describe()
def test_only_advanced_asks_before_starting(monkeypatch):
from aliens_eye import cli
asked = []
monkeypatch.setattr(cli.Confirm, "ask", lambda *a, **k: asked.append(a[0]) or True)
assert cli.confirm_scan_cost("basic", "someone", 854, console=None) is True
assert cli.confirm_scan_cost("intermediate", "someone", 854, console=None) is True
assert asked == []
assert cli.confirm_scan_cost("advanced", "someone", 854, console=None) is True
assert len(asked) == 1 and "105" in asked[0]
def test_declining_the_warning_is_reported(monkeypatch):
from aliens_eye import cli
monkeypatch.setattr(cli.Confirm, "ask", lambda *a, **k: False)
assert cli.confirm_scan_cost("advanced", "someone", 854, console=None) is False
def test_the_prompt_defaults_to_no(monkeypatch):
from aliens_eye import cli
seen = {}
monkeypatch.setattr(cli.Confirm, "ask", lambda *a, **k: seen.update(k) or False)
cli.confirm_scan_cost("advanced", "someone", 854, console=None)
assert seen["default"] is False
def test_the_scan_banner_states_the_cost_for_multi_variation_levels(tmp_path, logger):
import asyncio
import io
from rich.console import Console
from test_scanner import make_scanner
buffer = io.StringIO()
scanner = make_scanner({"alpha": "http://127.0.0.1:9/{}"}, tmp_path, logger)
scanner.console = Console(file=buffer, width=140, force_terminal=False)
async def run():
scanner.scan_all_sites = lambda name: asyncio.sleep(0, result=[]) # no network
await scanner.scan_with_variations("someone", "advanced")
asyncio.run(run())
assert "123 username variation" in buffer.getvalue()
assert "requests" in buffer.getvalue()
def test_declining_an_expensive_level_asks_for_a_level_again(monkeypatch):
from aliens_eye import cli
picks = iter(["advanced", "basic"])
monkeypatch.setattr(cli, "prompt_scan_level", lambda: next(picks))
monkeypatch.setattr(cli.Confirm, "ask", lambda *a, **k: False)
assert cli.choose_scan_level("someone", 854, console=None) == "basic"
def test_accepting_an_expensive_level_keeps_it(monkeypatch):
from aliens_eye import cli
monkeypatch.setattr(cli, "prompt_scan_level", lambda: "advanced")
monkeypatch.setattr(cli.Confirm, "ask", lambda *a, **k: True)
assert cli.choose_scan_level("someone", 854, console=None) == "advanced"
# --- the author's other project, shown under the banner ---------------------------------
def banner_text(monkeypatch, env=None):
import io
from rich.console import Console
from aliens_eye import cli
buffer = io.StringIO()
monkeypatch.setattr(cli, "get_console", lambda: Console(file=buffer, width=120, force_terminal=False, legacy_windows=False))
monkeypatch.delenv("ALIENS_EYE_NO_PROMO", raising=False)
for key, value in (env or {}).items():
monkeypatch.setenv(key, value)
cli.display_banner(854)
return buffer.getvalue()
def test_the_banner_mentions_the_authors_new_project(monkeypatch):
text = banner_text(monkeypatch)
assert "New from the author: lxask, a Linux command assistant that runs offline" in text
assert "https://github.com/arxhr007/lxask" in text
def promo_lines(text):
lines = text.splitlines()
top = max(i for i, line in enumerate(lines) if line.lstrip().startswith("╭")) # rounded box corner
bottom = next(i for i in range(top, len(lines)) if lines[i].lstrip().startswith("╰"))
return lines[top:bottom + 1]
def test_the_mention_is_in_a_box_with_a_star(monkeypatch):
box = promo_lines(banner_text(monkeypatch))
assert len(box) == 4 # top, the text, the link, bottom
assert "⭐" in box[1] and "lxask" in box[1]
assert "https://github.com/arxhr007/lxask" in box[2]
assert box[1].rstrip().endswith("│") and box[2].rstrip().endswith("│")
def test_the_link_is_never_split_across_lines(monkeypatch):
"""Copying or clicking a URL that wrapped mid-way does not work, so it has its own line."""
for width in (80, 100, 160):
import io
from rich.console import Console
from aliens_eye import cli
buffer = io.StringIO()
monkeypatch.setattr(cli, "get_console", lambda b=buffer, w=width: Console(file=b, width=w, force_terminal=False, legacy_windows=False))
monkeypatch.delenv("ALIENS_EYE_NO_PROMO", raising=False)
cli.display_banner(854)
assert any("https://github.com/arxhr007/lxask" in line for line in buffer.getvalue().splitlines()), width
def test_the_box_is_bright_gold(monkeypatch):
import io
from rich.console import Console
from aliens_eye import cli
buffer = io.StringIO()
monkeypatch.setattr(cli, "get_console", lambda: Console(
file=buffer, width=100, force_terminal=True, color_system="truecolor", legacy_windows=False))
monkeypatch.delenv("ALIENS_EYE_NO_PROMO", raising=False)
cli.display_banner(854)
gold = "38;2;255;215;0" # #FFD700
lines = [line for line in buffer.getvalue().splitlines() if "lxask" in line]
assert len(lines) == 2
for line in lines:
assert gold in line and "[1;" in line # gold, and bold for brightness
border = [line for line in buffer.getvalue().splitlines() if "╭" in line][-1]
assert gold in border
def test_a_console_that_cannot_show_emoji_gets_a_plain_box():
import io
from rich.console import Console
from aliens_eye import cli
raw = io.BytesIO()
console = Console(file=io.TextIOWrapper(raw, encoding="ascii", errors="strict"), width=100,
force_terminal=False, legacy_windows=False)
console.print(cli._promo_panel(console))
console.file.flush()
text = raw.getvalue().decode("ascii") # would raise if anything non-ASCII were written
assert "lxask" in text and "*" in text
def test_the_mention_can_be_turned_off(monkeypatch):
for value in ("1", "true", "yes"):
assert "lxask" not in banner_text(monkeypatch, {"ALIENS_EYE_NO_PROMO": value})
def test_an_empty_or_zero_setting_does_not_turn_it_off(monkeypatch):
for value in ("", "0", "false"):
assert "lxask" in banner_text(monkeypatch, {"ALIENS_EYE_NO_PROMO": value})
def test_json_stdout_stays_clean():
"""The banner is skipped for --json-stdout, so nothing but JSON reaches stdout."""
import inspect
from aliens_eye import cli
source = inspect.getsource(cli)
assert "if not config.json_stdout:\n display_banner(" in source
def test_the_library_api_and_mcp_server_never_print_it():
import pathlib
root = pathlib.Path(__file__).resolve().parents[1] / "src" / "aliens_eye"
for name in ("api.py", "mcp_server.py"):
assert "lxask" not in (root / name).read_text("utf-8")
def test_a_legacy_windows_console_gets_a_plain_star_but_still_a_box():
import io
from rich.console import Console
from aliens_eye import cli
buffer = io.StringIO()
console = Console(file=buffer, width=100, force_terminal=False, legacy_windows=True)
console.print(cli._promo_panel(console))
text = buffer.getvalue()
assert "⭐" not in text and "* New from the author" in text
assert "https://github.com/arxhr007/lxask" in text
assert text.splitlines()[0].strip() and text.splitlines()[-1].strip() # a top and a bottom edge