memberjojo 1.0__tar.gz → 1.1__tar.gz

{memberjojo-1.0 → memberjojo-1.1}/PKG-INFO

@@ -1,11 +1,13 @@
 Metadata-Version: 2.4
 Name: memberjojo
-Version: 1.0
+Version: 1.1
 Summary: memberjojo - tools for working with members.
 Author-email: Duncan Bellamy <dunk@denkimushi.com>
+Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-Expression: MIT
 License-File: LICENSE
+Requires-Dist: coverage ; extra == "dev"
 Requires-Dist: flit ; extra == "dev"
 Requires-Dist: pytest ; extra == "dev"
 Requires-Dist: furo ; extra == "docs"
@@ -13,7 +15,6 @@ Requires-Dist: myst-parser>=2.0 ; extra == "docs"
 Requires-Dist: sphinx>=7.0 ; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints ; extra == "docs"
 Requires-Dist: black ; extra == "lint"
-Requires-Dist: coverage ; extra == "lint"
 Requires-Dist: pylint ; extra == "lint"
 Project-URL: Home, https://github.com/a16bitsysop/memberjojo
 Provides-Extra: dev

{memberjojo-1.0 → memberjojo-1.1}/pyproject.toml

@@ -9,18 +9,19 @@ readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
 dynamic = ["version", "description"]
+requires-python = ">=3.8"
 
 [project.urls]
 Home = "https://github.com/a16bitsysop/memberjojo"
 
 [project.optional-dependencies]
 dev = [
+    "coverage",
     "flit",
     "pytest",
 ]
 lint = [
     "black",
-    "coverage",
     "pylint",
 ]
 docs = [
@@ -31,7 +32,8 @@ docs = [
 ]
 
 [tool.flit.sdist]
-exclude = [".gitignore"]
+exclude = ["**/.DS_Store"]
+include = ["tests", "src/memberjojo/_version.py"]
 
 [tool.setuptools_scm]
 write_to = "src/memberjojo/_version.py"

{memberjojo-1.0 → memberjojo-1.1}/src/memberjojo/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.0'
-__version_tuple__ = version_tuple = (1, 0)
+__version__ = version = '1.1'
+__version_tuple__ = version_tuple = (1, 1)

memberjojo-1.1/tests/test_mojo_members.py

@@ -0,0 +1,185 @@
+"""
+Tests for the member module
+"""
+
+from csv import DictWriter
+from pathlib import Path
+from tempfile import NamedTemporaryFile
+
+import pytest
+from memberjojo import Member
+
+# pylint: disable=redefined-outer-name
+# or pylint thinks fixtures are redined as function variables
+# --- Fixtures & Helpers ---
+
+
+@pytest.fixture
+def mock_csv_file(tmp_path):
+    """
+    Create a temporary mock CSV file for testing.
+    Returns path to the CSV.
+    """
+    fieldnames = [
+        "Member number",
+        "Title",
+        "First name",
+        "Last name",
+        "membermojo ID",
+        "Short URL",
+    ]
+    rows = [
+        {
+            "Member number": "1",
+            "Title": "Mr",
+            "First name": "John",
+            "Last name": "Doe",
+            "membermojo ID": "1001",
+            "Short URL": "http://short.url/johndoe",
+        },
+        {
+            "Member number": "2",
+            "Title": "Ms",
+            "First name": "Jane",
+            "Last name": "Smith",
+            "membermojo ID": "1002",
+            "Short URL": "http://short.url/janesmith",
+        },
+        {
+            "Member number": "3",
+            "Title": "Dr",
+            "First name": "Emily",
+            "Last name": "Stone",
+            "membermojo ID": "1001",
+            "Short URL": "http://short.url/emilystone",
+        },  # duplicate ID
+        {
+            "Member number": "1",
+            "Title": "Mrs",
+            "First name": "Sara",
+            "Last name": "Connor",
+            "membermojo ID": "1003",
+            "Short URL": "http://short.url/saraconnor",
+        },  # duplicate number
+        {
+            "Member number": "4",
+            "Title": "Sir",
+            "First name": "Rick",
+            "Last name": "Grimes",
+            "membermojo ID": "1004",
+            "Short URL": "http://short.url/rickgrimes",
+        },  # invalid title
+    ]
+
+    csv_path = tmp_path / "mock_data.csv"
+    with csv_path.open(mode="w", encoding="ISO-8859-1", newline="") as f:
+        writer = DictWriter(f, fieldnames=fieldnames)
+        writer.writeheader()
+        writer.writerows(rows)
+
+    return Path(csv_path)
+
+
+@pytest.fixture
+def db_path():
+    """
+    Temp file for db connection
+    """
+    with NamedTemporaryFile(suffix=".db", delete=False) as tmp:
+        path = Path(tmp.name)
+    yield path
+    path.unlink()
+
+
+@pytest.fixture
+def member_db(db_path, mock_csv_file):
+    """
+    Test sqlite member database
+    """
+    test_db = Member(db_path)
+    test_db.import_csv(mock_csv_file)
+    return test_db
+
+
+# --- Tests ---
+
+
+def test_empty_db(capsys):
+    """
+    Test empty db
+    """
+    with NamedTemporaryFile(suffix=".db") as tmp:
+        empty_db = Member(tmp.name)
+        # create tables so is empty database
+        empty_db._create_tables()  # pylint: disable=protected-access
+        empty_db.show_table()
+        captured = capsys.readouterr()
+        assert "(No data)" in captured.out
+        assert empty_db.count() == 0
+
+
+def test_invalid_csv_path_message(tmp_path, db_path, capsys):
+    """
+    Test import non existing csv file
+    """
+    non_exist = Path(tmp_path, "non-exist.csv")
+    txn = Member(db_path)
+    txn.import_csv(non_exist)
+    # Capture stdout
+    captured = capsys.readouterr()
+    assert "CSV file not found" in captured.out
+    assert str(non_exist) in captured.out
+
+
+def test_member_import_and_validation(member_db):
+    """
+    Test importing valid/invalid members from CSV.
+    """
+    # Valid inserts
+    assert member_db.get_number_first_last("john", "doe") == 1
+    assert member_db.get_number("Jane Smith") == 2
+    assert member_db.get_name(2) == "Jane Smith"
+    # Invalid member number
+    assert member_db.get_name(888) is None
+
+    # Should not be inserted due to duplicate membermojo ID
+    assert member_db.get_number_first_last("Emily", "Stone") is None
+
+    # Should not be inserted due to duplicate member_number
+    assert member_db.get_number("Sara Connor") is None
+
+    # Should not be inserted due to invalid title
+    assert member_db.get_number_first_last("Rick", "Grimes") is None
+
+
+def test_show_table(member_db):
+    """
+    Test the show table function
+    """
+    # Should be equal as default show_table is 5 entries and member_db is 2
+    entries = member_db.count()
+    assert entries == 2
+    assert member_db.show_table() == member_db.show_table(100)
+    assert member_db.show_table(entries) == member_db.show_table(100)
+
+
+def test_get_number_first_last_not_found_raises(member_db):
+    """
+    Test found_error
+    """
+    with pytest.raises(
+        ValueError, match=r"❌ Cannot find: John Snow in member database."
+    ):
+        member_db.get_number_first_last("John", "Snow", found_error=True)
+
+
+def test_get_number_first_last_more_names(member_db):
+    """
+    Test logic for 3 names passed
+    """
+    assert member_db.get_number("Dr Jane Smith") == 2
+    assert member_db.get_number("John Jojo Doe") == 1
+    with pytest.raises(ValueError) as exc_info:
+        member_db.get_number("Emily Sara", found_error=True)
+
+    assert "Cannot find" in str(exc_info.value)

memberjojo-1.1/tests/test_mojo_members_iter.py

@@ -0,0 +1,66 @@
+"""
+Iteration tests for the Member class
+"""
+
+import csv
+from memberjojo import Member, MemberData
+
+
+def test_member_iter(tmp_path):
+    """
+    Test for iterating over the member data.
+    """
+    # Prepare sample CSV data
+    sample_csv = tmp_path / "members.csv"
+    sample_data = [
+        {
+            "Member number": "11",
+            "Title": "Mr",
+            "First name": "Johnny",
+            "Last name": "Doe",
+            "membermojo ID": "8001",
+            "Short URL": "http://short.url/johnny",
+        },
+        {
+            "Member number": "12",
+            "Title": "Ms",
+            "First name": "Janice",
+            "Last name": "Smith",
+            "membermojo ID": "8002",
+            "Short URL": "http://short.url/janice",
+        },
+    ]
+
+    # Write CSV file
+    with sample_csv.open("w", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=sample_data[0].keys())
+        writer.writeheader()
+        writer.writerows(sample_data)
+
+    # Create DB path
+    db_path = tmp_path / "test_members.db"
+
+    # Instantiate Member and import CSV
+    members = Member(db_path)
+    members.import_csv(sample_csv)
+
+    # Collect members from iterator
+    iterated_members = list(members)
+
+    # Check that iteration yields correct number of members
+    assert len(iterated_members) == len(sample_data)
+
+    # Check that fields match for first member
+    first = iterated_members[0]
+    assert isinstance(first, MemberData)
+    assert first.member_num == int(sample_data[0]["Member number"])
+    assert first.title == sample_data[0]["Title"]
+    assert first.first_name == sample_data[0]["First name"]
+    assert first.last_name == sample_data[0]["Last name"]
+    assert first.membermojo_id == int(sample_data[0]["membermojo ID"])
+    assert first.short_url == sample_data[0]["Short URL"]
+
+    # Check second member also matches
+    second = iterated_members[1]
+    assert second.first_name == sample_data[1]["First name"]
+    assert second.last_name == sample_data[1]["Last name"]

memberjojo-1.1/tests/test_mojo_transactions.py

@@ -0,0 +1,240 @@
+"""
+Tests for the transaction module
+"""
+
+import tempfile
+import csv
+from pathlib import Path
+
+import pytest
+from memberjojo import Transaction  # Update with your actual module name
+
+# pylint: disable=redefined-outer-name
+# or pylint thinks fixtures are redined as function variables
+# --- Fixtures & Helpers ---
+
+
+@pytest.fixture
+def csv_file(tmp_path):
+    """
+    Temp csv file for testing
+    """
+    path = tmp_path / "test_data.csv"
+    data = [
+        {"id": "1", "amount": "100.5", "desc": "Deposit"},
+        {"id": "2", "amount": "200", "desc": "Withdrawal"},
+        {"id": "3", "amount": "150", "desc": "Refund"},
+        {"id": "4", "amount": "175", "desc": None},
+        {"id": "5", "amount": "345", "desc": ""},
+    ]
+    with path.open("w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=["id", "amount", "desc"])
+        writer.writeheader()
+        writer.writerows(data)
+    return Path(path)
+
+
+@pytest.fixture
+def db_path():
+    """
+    Temp file for db connection
+    """
+    with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as tmp:
+        path = Path(tmp.name)
+    yield path
+    path.unlink()
+
+
+@pytest.fixture
+def payment_db(db_path, csv_file):
+    """
+    Test sqlite transaction database
+    """
+    test_db = Transaction(db_path)
+    test_db.import_csv(csv_file, pk_column="id")
+    return test_db
+
+
+@pytest.mark.parametrize(
+    "input_value, expected",
+    [
+        (None, "TEXT"),
+        ("", "TEXT"),
+        ("abc", "TEXT"),
+        ("123", "INTEGER"),
+        ("123.45", "REAL"),
+        ("   42   ", "INTEGER"),  # whitespace-trimmed input
+    ],
+)
+
+
+# --- Tests ---
+
+
+def test_guess_type_various(input_value, expected):
+    """
+    Test all the code paths in _guess_type
+    """
+    txn = Transaction(":memory:")
+    assert txn._guess_type(input_value) == expected  # pylint: disable=protected-access
+
+
+def test_empty_csv_import(tmp_path, db_path):
+    """
+    Test importing empty and just header csv
+    """
+    txn = Transaction(db_path)
+    empty_csv = tmp_path / "empty.csv"
+    empty_csv.write_text("", encoding="utf-8")  # Fully empty
+
+    assert empty_csv.exists()
+    assert empty_csv.stat().st_size == 0
+    with pytest.raises(ValueError, match="CSV file is empty."):
+        txn.import_csv(empty_csv)
+
+    # OR with only headers
+    empty_csv.write_text("id,amount,desc\n", encoding="utf-8")
+
+    # Use it in your import
+    with pytest.raises(ValueError, match="CSV file is empty."):
+        txn.import_csv(empty_csv)
+
+
+def test_create_table_with_default_pk(csv_file, db_path):
+    """
+    Test _create_tables uses first column as primary key when pk_column is None.
+    """
+    txn = Transaction(db_path, table_name="auto_pk_table")
+    txn.import_csv(Path(csv_file))  # No pk_column provided
+
+    # Validate schema — first column should be the primary key
+    txn.cursor.execute("PRAGMA table_info(auto_pk_table)")
+    schema = txn.cursor.fetchall()
+    pk_cols = [col["name"] for col in schema if col["pk"] == 1]
+
+    assert pk_cols == ["id"]
+
+
+def test_invalid_csv_path_message(tmp_path, db_path, capsys):
+    """
+    Test import non existing csv file
+    """
+    non_exist = Path(tmp_path, "non-exist.csv")
+    txn = Transaction(db_path)
+    txn.import_csv(non_exist)
+    # Capture stdout
+    captured = capsys.readouterr()
+    assert "CSV file not found" in captured.out
+    assert str(non_exist) in captured.out
+
+
+def test_type_mismatch_in_second_import_raises(tmp_path, db_path):
+    """
+    Import valid CSV first. Then try a second CSV with invalid type, and ensure it raises.
+    """
+    txn = Transaction(db_path, table_name="payments")
+
+    # First CSV: valid
+    valid_csv = tmp_path / "valid.csv"
+    valid_csv.write_text(
+        ("id,amount,desc\n" + "1,100.0,Deposit\n" + "2,200.0,Withdrawal\n"),
+        encoding="utf-8",
+    )
+    txn.import_csv(valid_csv, pk_column="id")
+
+    # Second CSV: invalid amount type
+    invalid_csv = tmp_path / "invalid.csv"
+    invalid_csv.write_text(
+        (
+            "id,amount,desc\n"
+            + "3,not_a_number,Invalid Amount\n"
+            + "6,not_a_number,Invalid Amount\n"
+            + "7,not_a_number1,Invalid Amount\n"
+            + "8,not_a_number2,Invalid Amount\n"
+            + "9,not_a_number3,Invalid Amount\n"
+            + "10,not_a_number4,Invalid Amount\n"
+        ),
+        encoding="utf-8",
+    )
+
+    # Reuse the same txn instance so the schema remains
+    with pytest.raises(ValueError, match="Failed to import:"):
+        txn.import_csv(invalid_csv, pk_column="id")
+
+    # Ensure the invalid row was not inserted
+    assert txn.count() == 2
+
+
+def test_import_with_custom_primary_key(csv_file, db_path):
+    """
+    test_import_with_custom_primary_key
+    """
+    txn = Transaction(db_path, table_name="transactions")
+
+    # Import using 'amount' as the PK
+    txn.import_csv(Path(csv_file), pk_column="amount")
+
+    # Check that 'amount' is used as primary key
+    txn.cursor.execute("PRAGMA table_info(transactions)")
+    schema = txn.cursor.fetchall()
+    pk_columns = [col["name"] for col in schema if col["pk"] == 1]
+    assert pk_columns == ["amount"], "Expected 'amount' to be primary key"
+
+    # Check row count
+    assert txn.count() == 5
+
+    # Retrieve row by primary key
+    row = txn.get_row("amount", 200.0)
+    assert row is not None
+    assert row["desc"] == "Withdrawal"
+    assert row["id"] == 2
+    # Test null entry_value
+    assert txn.get_row("amount", "") is None
+
+
+def test_import_missing_primary_key(csv_file, db_path):
+    """
+    test_import_with_custom_primary_key
+    """
+    txn = Transaction(db_path, table_name="transactions")
+
+    with pytest.raises(
+        ValueError, match="Primary key column 'none_id' not found in CSV."
+    ):
+        # Import using 'none_id' as the PK
+        txn.import_csv(Path(csv_file), pk_column="none_id")
+
+
+def test_duplicate_primary_key_ignored(payment_db, csv_file):
+    """
+    test_duplicate_primary_key_ignored
+    """
+
+    # Re-import same CSV — should ignore duplicates due to OR IGNORE
+    payment_db.import_csv(Path(csv_file), pk_column="id")
+
+    assert payment_db.count() == 5  # No duplicates added
+
+
+def test_get_row_multi(payment_db):
+    """
+    Test retrieving a row using multiple column conditions
+    """
+
+    # Exact match for id=2 and desc='Withdrawal'
+    row = payment_db.get_row_multi({"id": "2", "desc": "Withdrawal"})
+    assert row is not None
+    assert row["id"] == 2
+    assert row["desc"] == "Withdrawal"
+    assert row["amount"] == 200.0
+
+    # Match with numeric and empty string
+    row = payment_db.get_row_multi({"id": "5", "desc": ""})
+    assert row is not None
+    assert row["id"] == 5
+    assert row["desc"] is None
+    assert row["amount"] == 345.0
+
+    # No match
+    row = payment_db.get_row_multi({"id": "3", "desc": "Not a match"})
+    assert row is None

memberjojo-1.1/tests/test_version.py

@@ -0,0 +1,27 @@
+"""
+Test for _version.py not present
+"""
+
+import importlib
+import sys
+from unittest import mock
+
+
+def test_version_fallback():
+    """
+    Remove _version to test for missing _version.py
+    """
+
+    # Remove the _version module from sys.modules if present
+    sys.modules.pop("memberjojo._version", None)
+
+    # Patch sys.modules so importing memberjojo._version raises ImportError
+    with mock.patch.dict("sys.modules", {"memberjojo._version": None}):
+        # Remove the main package module so reload triggers fresh import logic
+        sys.modules.pop("memberjojo", None)
+
+        import memberjojo  # pylint: disable=import-outside-toplevel
+
+        importlib.reload(memberjojo)
+
+        assert memberjojo.__version__ == "0.0.0+local"