Free AI Unit Test Generator – Generate Tests in Seconds

export function normalizePrice(input, currency = "USD"){
  if(input == null) return null
  const value = typeof input === "string" ? Number(input.replace(/[^0-9.-]/g,"")) : Number(input)
  if(isNaN(value)) return null
  const cents = Math.round(value * 100)
  return { cents, currency }
}

Summary:
Test the normalizePrice function for correct parsing and rounding of numeric inputs and strings with currency symbols, including handling of null and invalid inputs. This provides confidence that price normalization behaves correctly across typical and edge cases.

Test Plan:
1. Input is a valid number (e.g., 12.34) returns correct cents and default currency.
2. Input is a numeric string with currency symbol (e.g., "$12.34") returns correct cents and default currency.
3. Input is null returns null.
4. Input is a non-numeric string returns null.
5. Input is a negative number returns correct negative cents.
6. Input is zero returns zero cents.
7. Input is a number with more than two decimal places rounds correctly.
8. Input is a number with currency parameter specified returns correct currency.
9. Input is a string with multiple currency symbols and spaces returns correct cents.
10. Input is a string with invalid characters mixed with numbers returns correct cents ignoring invalid chars.

Edge Cases:
- Null input
- Empty string input
- Negative values
- Very large numbers
- Strings with multiple symbols or spaces
- Non-numeric strings
- Numbers with many decimal places

Generated Tests:
import unittest
from yourmodule import normalizePrice

class TestNormalizePrice(unittest.TestCase):
    def testvalidnumber(self):
        result = normalizePrice(12.34)
        self.assertEqual(result, {'cents': 1234, 'currency': 'USD'})

    def testnumericstringwithsymbol(self):
        result = normalizePrice("$12.34")
        self.assertEqual(result, {'cents': 1234, 'currency': 'USD'})

    def testnullinput(self):
        result = normalizePrice(None)
        self.assertIsNone(result)

    def testnonnumericstring(self):
        result = normalizePrice("abc")
        self.assertIsNone(result)

    def testnegativenumber(self):
        result = normalizePrice(-5.67)
        self.assertEqual(result, {'cents': -567, 'currency': 'USD'})

    def testzeroinput(self):
        result = normalizePrice(0)
        self.assertEqual(result, {'cents': 0, 'currency': 'USD'})

    def testrounding(self):
        result = normalizePrice("12.3456")
        self.assertEqual(result, {'cents': 1235, 'currency': 'USD'})

    def testcustomcurrency(self):
        result = normalizePrice("12.34", "EUR")
        self.assertEqual(result, {'cents': 1234, 'currency': 'EUR'})

    def teststringwithmultiplesymbols(self):
        result = normalizePrice("  $ 12.34 ")
        self.assertEqual(result, {'cents': 1234, 'currency': 'USD'})

    def teststringwithinvalidchars(self):
        result = normalizePrice("12abc34.56xyz")
        self.assertEqual(result, {'cents': 123456, 'currency': 'USD'})

if name == 'main':
    unittest.main()

When To Stop:
Stop when all input types and edge cases are covered and no new failure modes are found. Focus on inputs that could realistically occur in production to balance risk and test effort.

def slugify(text):
    if text is None:
        return ""
    out = []
    for ch in text.lower():
        if ch.isalnum():
            out.append(ch)
        elif ch.isspace():
            out.append("-")
    return "-".join("".join(out).split("-"))

Summary:
The slugify function will be tested for correct conversion of input strings into URL-friendly slugs, including handling of None, spaces, alphanumeric characters, and special characters. Confidence is high for typical inputs and common edge cases.

Test Plan:
1. Input is None, expect empty string output.
2. Input is an empty string, expect empty string output.
3. Input contains only alphanumeric characters, expect lowercase unchanged string.
4. Input contains spaces, expect spaces replaced by single hyphens.
5. Input contains multiple consecutive spaces, expect single hyphen separators without duplicates.
6. Input contains special characters (non-alphanumeric, non-space), expect removal of those characters.
7. Input contains uppercase letters, expect conversion to lowercase.
8. Input contains mixed alphanumeric and special characters, expect correct filtering and hyphen insertion.
9. Input contains leading and trailing spaces, expect no leading or trailing hyphens.
10. Input contains only spaces, expect empty string output.

Edge Cases:
- None input
- Empty string
- Multiple consecutive spaces
- Leading/trailing spaces
- All special characters
- Mixed case letters
- Long strings

Generated Tests:
import pytest

from unittest.mock import patch

from slugifymodule import slugify   assuming function is in slugifymodule.py

@pytest.mark.parametrize("inputtext, expected", [
    (None, ""),
    ("", ""),
    ("abc123", "abc123"),
    ("Hello World", "hello-world"),
    ("Hello   World", "hello-world"),
    ("Hello, World!", "hello-world"),
    ("UPPER lower", "upper-lower"),
    ("Mix3d Ch@r$ & Spaces", "mix3d-chr-spaces"),
    ("  Leading and trailing  ", "leading-and-trailing"),
    ("     ", ""),
])
def testslugify(inputtext, expected):
    assert slugify(inputtext) == expected

When To Stop:
Testing covers typical, edge, and failure inputs with high confidence. Additional tests may be added for very long strings or Unicode characters if needed, but current coverage is sufficient for most practical uses.