class TestCase:
    def __init__(self, name):
        self.name = name
    def run(self):
        '''
        메서드 동적 호출
        getattr(object, name, default)는 object 내에서 주어진 string(name)과 동일한 method를 반환해준다.
        따라서 테스트케이스의 이름을 전달했을 때, 해당 테스트케이스가 호출되었는지를 기록할 수 있다.
        '''
        method = getattr(self, self.name) # 상수를 변수(method)로 변화시켜 일반화하는 리팩토링의 예
        method()
class WasRun(TestCase):
    def __init__(self, name):
        self.wasRun = None # 테스트케이스가 호출되었는지를 알려주는 어트리뷰트
        TestCase.__init__(self, name)
    def testMethod(self):
        '''
        메서드 호출여부 기록
        메서드가 호출되었는지를 기억(flag)하는 메서드
        '''
        self.wasRun = 1
class TestCaseTest(TestCase):
    def testRunning(self):
        '''
        test 코드 실행 메서드
        실행 과정을 print문이 아니라 assertion 형태로 구현
        '''
        test = WasRun("testMethod")
        assert(not test.wasRun) # not None이므로, True 반환
        test.run() # testMethod()를 직접 호출하지 않고, run()이라는 함수를 두어 두 부분을 분리함
        assert(test.wasRun) # 1
# main
TestCaseTest("testRunning").run() # 성공!

class TestCase():
    def __init__(self, name):
        self.name = name
    def setUp(self):
        '''
        하위 클래스(WasRun,TestCaseTest)에서 오버라이드할 추상 메서드
        '''
        pass
    def run(self):
        '''
        메서드 동적 호출
        getattr(object, name, default)는 object 내에서 주어진 string(name)과 동일한 method를 반환해준다.
        따라서 테스트케이스의 이름을 전달했을 때, 해당 테스트케이스가 호출되었는지를 기록할 수 있다.
        '''
        self.setUp()
        method = getattr(self, self.name) # 상수를 변수(method)로 변화시켜 일반화하는 리팩토링의 예
        method()
class WasRun(TestCase):
    '''
    메서드가 실행되었는지를 알려주는 테스트클래스
    '''
    def __init__(self, name):
        self.wasRun = None # 테스트케이스가 호출되었는지를 알려주는 어트리뷰트
        TestCase.__init__(self, name)
    def testMethod(self):
        '''
        메서드 호출여부 기록
        메서드가 호출되었는지를 기억(flag)하는 메서드
        '''
        self.wasRun = 1
    def setUp(self):
        '''
        setUp 여부 기록
        여러 테스트를 실행할 때, 테스트 커플링을 피하기 위해(환경을 독립시키기 위해) 사용하는 일종의 세팅 메서드
        '''
        self.wasRun = None
        self.wasSetUp = 1
class TestCaseTest(TestCase):
    '''
    테스트케이스를 수행하는 메인 클래스
    '''
    def setUp(self):
        '''
        WasRun 인스턴스 생성 파트(각 테스트메서드마다 인스턴스를 분리하기 위하여)
        '''
        self.test = WasRun("testMethod")
    def testRunning(self):
        '''
        test 코드 실행 테스트코드
        '''
        # assert(not self.test.wasRun) # test-setUp이 존재하고 잘 돌아가므로 wasRun을 검사할 필요가 없어졌다(단순화)
        self.test.run()
        assert(self.test.wasRun) # 1
    def testSetUp(self):
        '''
        setUp 메서드 호출여부 테스트코드
        '''
        self.test.run()
        assert(self.test.wasSetUp)
# main
TestCaseTest("testRunning").run()
TestCaseTest("testSetUp").run()

class TestCase():
    def __init__(self, name):
        self.name = name
    def setUp(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def tearDown(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def run(self):
        '''
        메서드 동적 호출
        getattr(object, name, default)는 object 내에서 주어진 string(name)과 동일한 method를 반환해준다.
        따라서 테스트케이스의 이름을 전달했을 때, 해당 테스트케이스가 호출되었는지를 기록할 수 있다.
        '''
        self.setUp()
        method = getattr(self, self.name) # 상수를 변수(method)로 변화시켜 일반화하는 리팩토링의 예
        method()
        self.tearDown()
class WasRun(TestCase):
    '''
    메서드가 실행되었는지를 알려주는 테스트클래스
    '''
    def __init__(self, name):
        TestCase.__init__(self, name)
    def setUp(self):
        '''
        setUp 여부 기록
        여러 테스트를 실행할 때, 테스트 커플링을 피하기 위해(환경을 독립시키기 위해) 사용하는 일종의 세팅 메서드
        '''
        # self.wasSetUp = 1 # 플래그는 순서를 기록할 수 없다. 따라서 테스트 코드 호출전에 setUp과 tearDown의 순서를 보장할 수 없다.
        self.log = "setUp" # 플래그대신 로그를 사용하여 코드의 흐름을 확실히 한다.
    def testMethod(self):
        '''
        테스트메서드 호출여부 기록
        메서드가 호출되었는지를 기억(flag)하는 메서드
        '''
        self.log += " testMethod"
    def tearDown(self):
        '''
        tearDown 여부 기록
        테스트를 위해 setUp에서 할당받은 외부 자원을, 테스트가 종료되면 반환하는 메서드
        '''
        self.log += " tearDown"
class TestCaseTest(TestCase):
    '''
    테스트케이스를 수행하는 메인 클래스
    '''
    def testTemplateMethod(self): # testSetUp의 진화! (testRunning 메서드는 이제 필요없음.)
        '''
        setUp과 tearDown의 호출 순서 체크 테스트코드
        '''
        test = WasRun("testMethod") # 이제 test-SetUp과 Running 두 군데서 사용하지 않으니, setUp 메서드도 삭제하고 리팩토링을 되돌린다.
        test.run()
        assert("setUp testMethod tearDown" == test.log) # 플래그 대신에 로그를 검
# main
TestCaseTest("testTemplateMethod").run()

class TestCase():
    def __init__(self, name):
        self.name = name
    def setUp(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def tearDown(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def run(self):
        '''
        메서드 동적 호출
        '''
        result = TestResult() # 실행결과 객체 할당
        result.testStarted() # 실행 카운트 기록
        self.setUp()
        method = getattr(self, self.name)
        method()
        self.tearDown()
        return result
class WasRun(TestCase):
    '''
    메서드가 실행되었는지를 알려주는 테스트클래스
    '''
    def __init__(self, name):
        TestCase.__init__(self, name)
    def setUp(self):
        '''
        setUp 여부 기록
        여러 테스트를 실행할 때, 테스트 커플링을 피하기 위해(환경을 독립시키기 위해) 사용하는 일종의 세팅 메서드
        '''
        self.log = "setUp"
    def testMethod(self):
        '''
        테스트메서드 호출여부 기록
        메서드가 호출되었는지를 기억(flag)하는 메서드
        '''
        self.log += " testMethod"
    def testBrokenMethod(self):
        '''
        실패하는 테스트의 stub
        '''
        raise Exception # 이번 장에서는 아직 예외 핸들링을 하지 않았다!
    def tearDown(self):
        '''
        tearDown 여부 기록
        테스트를 위해 setUp에서 할당받은 외부 자원을, 테스트가 종료되면 반환하는 메드서
        '''
        self.log += " tearDown"
class TestCaseTest(TestCase):
    '''
    테스트케이스를 수행하는 메인 클래스
    '''
    def testTemplateMethod(self):
        '''
        setUp과 tearDown의 호출 순서 체크 테스트코드
        '''
        test = WasRun("testMethod")
        test.run()
        assert("setUp testMethod tearDown" == test.log)
    def testFailedResult(self):
        '''
        실패하는 테스트 수가 제대로 나오는지 체크하는 테스트코드
        '''
        test = WasRun("testBrokenMethod")
        result = test.run()
        assert("1 run, 1 failed" == result.summary())
    def testResult(self):
        '''
        실행결과가 제대로 나오는지 체크하는 테스트코드
        '''
        test = WasRun("testMethod")
        result = test.run()
        assert("1 run, 0 failed" == result.summary())
class TestResult:
    '''
    테스트메서드(들)의 실행결과를 기록하는 객체
    '''
    def __init__(self):
        self.runCount = 0 # 실행된 테스트의 수 0으로 초기화
    def testStarted(self):
        self.runCount = self.runCount + 1
    def summary(self):
        '''
        실행결과 반환 메서드
        '''
        return f"{self.runCount} run, 0 failed"
# main
TestCaseTest("testTemplateMethod").run()
TestCaseTest("testFailedResult").run()
TestCaseTest("testResult").run()

class TestCase():
    def __init__(self, name):
        self.name = name
    def setUp(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def tearDown(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def run(self):
        '''
        메서드 동적 호출
        '''
        result = TestResult() # 실행결과 객체 할당
        result.testStarted() # 실행 카운트 기록
        self.setUp() # 이 코드에서 setUp에 문제가 발생했을 경우에는 예외를 잡을 수 없다.
        try :
            method = getattr(self, self.name)
            method()
        except :
            result.testFailed() # 예외 발생시 Failed 카운트 올리기
        self.tearDown()
        return result
class WasRun(TestCase):
    '''
    메서드가 실행되었는지를 알려주는 테스트클래스
    '''
    def __init__(self, name):
        TestCase.__init__(self, name)
    def setUp(self):
        '''
        setUp 여부 기록
        여러 테스트를 실행할 때, 테스트 커플링을 피하기 위해(환경을 독립시키기 위해) 사용하는 일종의 세팅 메서드
        '''
        self.log = "setUp"
    def testMethod(self):
        '''
        테스트메서드 호출여부 기록
        메서드가 호출되었는지를 기억(flag)하는 메서드
        '''
        self.log += " testMethod"
    def testBrokenMethod(self):
        '''
        실패하는 테스트의 stub
        '''
        raise Exception # 이번 장에서는 아직 예외 핸들링을 하지 않았다!
    def tearDown(self):
        '''
        tearDown 여부 기록
        테스트를 위해 setUp에서 할당받은 외부 자원을, 테스트가 종료되면 반환하는 메드서
        '''
        self.log += " tearDown"
class TestCaseTest(TestCase):
    '''
    테스트케이스를 수행하는 메인 클래스
    '''
    def testTemplateMethod(self):
        '''
        setUp과 tearDown의 호출 순서 체크 테스트코드
        '''
        test = WasRun("testMethod")
        test.run()
        assert("setUp testMethod tearDown" == test.log)
    def testFailedResult(self):
        '''
        실패하는 테스트 수가 제대로 나오는지 체크하는 테스트코드
        '''
        test = WasRun("testBrokenMethod")
        result = test.run()
        assert("1 run, 1 failed" == result.summary())
    def testFailedResultFormatting(self):
        '''
        테스트 시작/실패 메시지 체크 테스트코드
        '''
        result = TestResult()
        result.testStarted() # 테스트 시작시 보내는 메시지
        result.testFailed() # 테스트 실패시 보내는 메시지
        assert("1 run, 1 failed" == result.summary())
    def testResult(self):
        '''
        실행결과가 제대로 나오는지 체크하는 테스트코드
        '''
        test = WasRun("testMethod")
        result = test.run()
        assert("1 run, 0 failed" == result.summary())
class TestResult:
    '''
    테스트메서드(들)의 실행결과를 기록하는 객체
    '''
    def __init__(self):
        self.runCount = 0 # 실행된 테스트의 수 0으로 초기화
        self.failureCount = 0
    def testStarted(self):
        self.runCount = self.runCount + 1
    def testFailed(self):
        self.failureCount += 1
    def summary(self):
        '''
        실행결과 반환 메서드
        '''
        return f"{self.runCount} run, {self.failureCount} failed"
# main
print(TestCaseTest("testTemplateMethod").run().summary())
print(TestCaseTest("testFailedResult").run().summary())
print(TestCaseTest("testResult").run().summary())
print(TestCaseTest("testFailedResultFormatting").run.summary())

class TestCase():
    def __init__(self, name):
        self.name = name
    def setUp(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def tearDown(self):
        '''
        하위 클래스 WasRun에서 오버라이드할 추상 메서드
        '''
        pass
    def run(self, result):
        '''
        메서드 동적 호출
        '''
        result.testStarted()
        self.setUp()
        try :
            method = getattr(self, self.name)
            method()
        except Exception as e :
            result.testFailed()
            print(e)
        self.tearDown()
        # return result # result를 명시적으로 반환할 필요가 없다! (가져온 result를 조작한 것이므로)
class WasRun(TestCase):
    '''
    메서드가 실행되었는지를 알려주는 테스트클래스
    '''
    def __init__(self, name):
        TestCase.__init__(self, name)
    def setUp(self):
        '''
        setUp 여부 기록
        여러 테스트를 실행할 때, 테스트 커플링을 피하기 위해(환경을 독립시키기 위해) 사용하는 일종의 세팅 메서드
        '''
        self.log = "setUp"
    def testMethod(self):
        '''
        테스트메서드 호출여부 기록
        메서드가 호출되었는지를 기억(flag)하는 메서드
        '''
        self.log += " testMethod"
    def testBrokenMethod(self):
        '''
        실패하는 테스트의 stub
        '''
        raise Exception
    def tearDown(self):
        '''
        tearDown 여부 기록
        테스트를 위해 setUp에서 할당받은 외부 자원을, 테스트가 종료되면 반환하는 메서드
        '''
        self.log += " tearDown"
class TestSuite:
    def __init__(self):
        self.tests = []
    def add(self, test):
        self.tests.append(test)
    def run(self, result):
        '''
        :param result: 호출부 TestCaseTest.testSuite()에서 만든 result를 매개변수로 받아 그대로 사용한다.
        '''
        for test in self.tests:
            test.run(result)
        # return result # result를 명시적으로 반환할 필요가 없다! (가져온 result를 조작한 것이므로)
class TestCaseTest(TestCase):
    '''
    테스트케이스를 수행하는 메인 클래스
    '''
    def setUp(self):
        '''
        각 메서드마다 TestResult()를 만들고 넘겨주고 할 것 없이, suite이 공유하는 result를 만든다.
        '''
        self.result = TestResult()
    def testTemplateMethod(self):
        '''
        setUp과 tearDown의 호출 순서 체크 테스트코드
        '''
        test = WasRun("testMethod")
        test.run(self.result)
        assert ("setUp testMethod tearDown" == test.log)
    def testResult(self):
        '''
        실행결과가 제대로 나오는지 체크하는 테스트코드
        '''
        test = WasRun("testMethod")
        test.run(self.result)
        assert ("1 run, 0 failed" == self.result.summary())
    def testFailedResult(self):
        '''
        실패하는 테스트 수가 제대로 나오는지 체크하는 테스트코드
        '''
        test = WasRun("testBrokenMethod")
        test.run(self.result)
        assert ("1 run, 1 failed" == self.result.summary())
    def testFailedResultFormatting(self):
        '''
        테스트 시작/실패 메시지 체크 테스트코드
        '''
        self.result.testStarted() # 테스트 시작시 보내는 메시지
        self.result.testFailed() # 테스트 실패시 보내는 메시지
        assert ("1 run, 1 failed" == self.result.summary())
    def testSuite(self):
        suite = TestSuite() # 테스트 스위트 - Composite
        suite.add(WasRun("testMethod")) # 1번 테스트 - 테스트스위트의 Component
        suite.add(WasRun("testBrokenMethod")) # 2번 테스트 - 테스트스위트의 Component
        suite.run(self.result) # 컬렉션을 Component처럼 이용한다. Composite 패턴의 예
        assert ("2 run, 1 failed" == self.result.summary()) # 2개의 테스트를 테스트 스위트로 묶어 수행하고, 1개가 실패했음
class TestResult:
    '''
    테스트메서드(들)의 실행결과를 기록하는 객체
    '''
    def __init__(self):
        self.runCount = 0 # 실행된 테스트의 수 0으로 초기화
        self.failureCount = 0
    def testStarted(self):
        self.runCount = self.runCount + 1
    def testFailed(self):
        self.failureCount += 1
    def summary(self):
        '''
        실행결과 반환 메서드
        '''
        return f"{self.runCount} run, {self.failureCount} failed"
# main
# 이전까지 하나씩 실행시켰던 것들을 suite로 한번에 묶어 처리한다.
suite = TestSuite()
suite.add(TestCaseTest("testTemplateMethod"))
suite.add(TestCaseTest("testResult"))
suite.add(TestCaseTest("testFailedResultFormatting"))
suite.add(TestCaseTest("testFailedResult"))
suite.add(TestCaseTest("testSuite"))
result = TestResult()
suite.run(result)
print(result.summary())