PythonにおけるassertRaisesメソッドの基本と活用例12選

import unittest

def divide(a, b):
    return a / b

class TestDivide(unittest.TestCase):
    def test_divide_by_zero(self):
        with self.assertRaises(ZeroDivisionError):
            divide(10, 0)

if __name__ == '__main__':
    unittest.main()

.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

import unittest

def convert_to_int(value):
    return int(value)

class TestConversion(unittest.TestCase):
    def test_valid_conversion(self):
        self.assertEqual(convert_to_int("10"), 10)

    def test_invalid_conversion(self):
        with self.assertRaises(ValueError):
            convert_to_int("abc")

if __name__ == '__main__':
    unittest.main()

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

import unittest

def check_adult_age(age):
    if not isinstance(age, int) or age < 0:
        raise ValueError("年齢は0以上の整数である必要があります")
    return age >= 18

class TestAdultAge(unittest.TestCase):
    def test_valid_adult_age(self):
        self.assertTrue(check_adult_age(20))

    def test_valid_minor_age(self):
        self.assertFalse(check_adult_age(15))

    def test_negative_age(self):
        with self.assertRaises(ValueError):
            check_adult_age(-5)

    def test_non_integer_age(self):
        with self.assertRaises(ValueError):
            check_adult_age("twenty")

if __name__ == '__main__':
    unittest.main()

....
----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

import unittest

def get_element(lst, index):
    if index < 0 or index >= len(lst):
        raise IndexError("インデックスが範囲外です")
    return lst[index]

class TestGetElement(unittest.TestCase):
    def test_valid_index(self):
        lst = [1, 2, 3, 4, 5]
        self.assertEqual(get_element(lst, 2), 3)

    def test_index_out_of_range(self):
        lst = [1, 2, 3]
        with self.assertRaises(IndexError):
            get_element(lst, 5)

    def test_no_exception(self):
        lst = [1, 2, 3]
        try:
            get_element(lst, 1)
        except IndexError:
            self.fail("予期せぬ例外が発生しました")

if __name__ == '__main__':
    unittest.main()

...
----------------------------------------------------------------------
Ran 3 tests in 0.001s

OK

import pytest

def check_adult_age(age):
    if not isinstance(age, int) or age < 0:
        raise ValueError("年齢は0以上の整数である必要があります")
    return age >= 18

def test_valid_adult_age():
    assert check_adult_age(20) == True

def test_valid_minor_age():
    assert check_adult_age(15) == False

def test_negative_age():
    with pytest.raises(ValueError):
        check_adult_age(-5)

def test_non_integer_age():
    with pytest.raises(ValueError):
        check_adult_age("twenty")

import unittest
import re

def validate_age(age):
    if not isinstance(age, int):
        raise ValueError(f"年齢は整数である必要があります。入力値: {age}")
    if age < 0 or age > 120:
        raise ValueError(f"年齢は0から120の間である必要があります。入力値: {age}")
    return True

class TestAgeValidation(unittest.TestCase):
    def test_non_integer_age(self):
        with self.assertRaisesRegex(ValueError, r"年齢は整数である必要があります。入力値: .*"):
            validate_age("twenty")

    def test_out_of_range_age(self):
        with self.assertRaisesRegex(ValueError, r"年齢は0から120の間である必要があります。入力値: \d+"):
            validate_age(150)

if __name__ == '__main__':
    unittest.main()

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

import unittest
import re

def validate_password(password):
    if len(password) < 8:
        raise ValueError("パスワードは8文字以上である必要があります")
    if not re.search(r"\d", password):
        raise ValueError("パスワードは少なくとも1つの数字を含む必要があります")
    if not re.search(r"[A-Z]", password):
        raise ValueError("パスワードは少なくとも1つの大文字を含む必要があります")
    return True

class TestPasswordValidation(unittest.TestCase):
    def test_short_password(self):
        with self.assertRaisesRegex(ValueError, r"パスワードは8文字以上である必要があります"):
            validate_password("abc123")

    def test_no_digit(self):
        with self.assertRaisesRegex(ValueError, r"パスワードは少なくとも1つの数字を含む必要があります"):
            validate_password("abcdefghA")

    def test_no_uppercase(self):
        with self.assertRaisesRegex(ValueError, r"パスワードは少なくとも1つの大文字を含む必要があります"):
            validate_password("abcdefgh1")

    def test_valid_password(self):
        self.assertTrue(validate_password("abcdefgH1"))

if __name__ == '__main__':
    unittest.main()

....
----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

import unittest
import requests
from unittest.mock import patch

class APIClient:
    def get_user(self, user_id):
        response = requests.get(f"https://api.example.com/users/{user_id}")
        if response.status_code == 404:
            raise ValueError("ユーザーが見つかりません")
        return response.json()

class TestAPIClient(unittest.TestCase):
    @patch('requests.get')
    def test_user_not_found(self, mock_get):
        mock_response = unittest.mock.Mock()
        mock_response.status_code = 404
        mock_get.return_value = mock_response

        client = APIClient()
        with self.assertRaises(ValueError):
            client.get_user(999)

if __name__ == '__main__':
    unittest.main()

.
----------------------------------------------------------------------
Ran 1 test in 0.001s

OK

import unittest
import re

def validate_email(email):
    if not re.match(r"[^@]+@[^@]+\.[^@]+", email):
        raise ValueError("無効なメールアドレスです")
    return True

class TestEmailValidation(unittest.TestCase):
    def test_valid_email(self):
        self.assertTrue(validate_email("user@example.com"))

    def test_invalid_email(self):
        with self.assertRaises(ValueError):
            validate_email("invalid_email")

if __name__ == '__main__':
    unittest.main()

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

import unittest
import os

def read_file(filename):
    if not os.path.exists(filename):
        raise FileNotFoundError(f"ファイルが見つかりません: {filename}")
    with open(filename, 'r') as file:
        return file.read()

class TestFileOperations(unittest.TestCase):
    def test_file_not_found(self):
        with self.assertRaises(FileNotFoundError):
            read_file("non_existent_file.txt")

    def test_file_read_success(self):
        with open("test_file.txt", "w") as f:
            f.write("テストデータ")
        self.assertEqual(read_file("test_file.txt"), "テストデータ")
        os.remove("test_file.txt")

if __name__ == '__main__':
    unittest.main()

..
----------------------------------------------------------------------
Ran 2 tests in 0.002s

OK

import unittest

class InsufficientFundsError(Exception):
    pass

class BankAccount:
    def __init__(self, balance):
        self.balance = balance

    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientFundsError("残高が不足しています")
        self.balance -= amount

class TestBankAccount(unittest.TestCase):
    def test_insufficient_funds(self):
        account = BankAccount(100)
        with self.assertRaises(InsufficientFundsError):
            account.withdraw(150)

    def test_successful_withdrawal(self):
        account = BankAccount(100)
        account.withdraw(50)
        self.assertEqual(account.balance, 50)

if __name__ == '__main__':
    unittest.main()

..
----------------------------------------------------------------------
Ran 2 tests in 0.001s

OK

import unittest

def process_data(data):
    if not isinstance(data, dict):
        raise TypeError("データは辞書形式である必要があります")
    if "key" not in data:
        raise KeyError("必須キー'key'が見つかりません")
    if not isinstance(data["key"], str):
        raise ValueError("'key'の値は文字列である必要があります")
    return data["key"].upper()

class TestDataProcessing(unittest.TestCase):
    def test_type_error(self):
        with self.assertRaises(TypeError):
            process_data([])

    def test_key_error(self):
        with self.assertRaises(KeyError):
            process_data({})

    def test_value_error(self):
        with self.assertRaises(ValueError):
            process_data({"key": 123})

    def test_successful_processing(self):
        result = process_data({"key": "value"})
        self.assertEqual(result, "VALUE")

if __name__ == '__main__':
    unittest.main()

....
----------------------------------------------------------------------
Ran 4 tests in 0.001s

OK

import unittest

class Calculator:
    def divide(self, a, b):
        pass  # 実装はまだありません

class TestCalculator(unittest.TestCase):
    def test_divide_by_zero(self):
        calc = Calculator()
        with self.assertRaises(ValueError):
            calc.divide(10, 0)

    def test_normal_division(self):
        calc = Calculator()
        self.assertEqual(calc.divide(10, 2), 5)

if __name__ == '__main__':
    unittest.main()

FF
======================================================================
FAIL: test_divide_by_zero (__main__.TestCalculator)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "<string>", line 11, in test_divide_by_zero
AssertionError: ValueError not raised

======================================================================
FAIL: test_normal_division (__main__.TestCalculator)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "<string>", line 15, in test_normal_division
AssertionError: None != 5

----------------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=2)

class Calculator:
    def divide(self, a, b):
        if b == 0:
            raise ValueError("ゼロで割ることはできません")
        return a / b

..
----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

import unittest

def divide(a, b):
    return a / b

class TestDivision(unittest.TestCase):
    def test_divide_by_zero(self):
        with self.assertRaises(ZeroDivisionError):
            divide(10, 1)  # ゼロで割っていないのでエラーにならない

if __name__ == '__main__':
    unittest.main()

F
======================================================================
FAIL: test_divide_by_zero (__main__.TestDivision)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "<string>", line 9, in test_divide_by_zero
AssertionError: ZeroDivisionError not raised

----------------------------------------------------------------------
Ran 1 test in 0.000s

FAILED (failures=1)