Finished Chap4

2020-11-07 21:36:51 +11:00 · 2020-11-07 21:36:51 +11:00 · 2a5302d2af
parent 22a38297a9
commit 2a5302d2af
5 changed files with 177 additions and 7 deletions
--- a/textbook/chap3.md
+++ b/textbook/chap3.md
@ -177,12 +177,20 @@ After creating simple `home_page` empty function. We can create test function in
 ```python
    def test_home_page_returns_correct_html(self):
-        request = HttpRequest()
+        """
-        response = home_page(request)
+        1. Create an HttpRequest object, which is what Django will see when a user's browser asks for a page
-        html = response.content.decode('utf8')
+        2. Pass it to `home_page` view, which gives us a response.
-        self.assertTrue(html.startswith('<html>'))
+        3. Extract `.content` of the response, which are byte value, and should be decoded into string (HTML format)
-        self.assertIn('<title>To-Do list</title>', html)
+        4. Check HTML starts and end with <html> tag
-        self.assertTrue(html.endswith('</html>'))
+        5. Want to find <title> tag in the middle
        """
        request = HttpRequest() #1
        response = home_page(request) #2
        html = response.content.decode('utf8') #3
        self.assertTrue(html.startswith('<html>')) #4
        self.assertIn('<title>To-Do lists</title>', html.strip()) #5
        self.assertTrue(html.strip().endswith('</html>')) #4
 ```
 Result of `python manager.py test` is: 
--- a/textbook/chap4.md
+++ b/textbook/chap4.md
@ -0,0 +1,162 @@
 # Chapter 4. What Are We Doing with All These Tests? (And, Refactoring)
 ## 4.1 Programming is like pulling a bucket of water up from a well
 TDD is **discipline**. Its payoffs not come immediately
 ## 4.2 Using selenium to test user interactions
 Modify `functional_tests.py` to test user interactions
 ```python
 from selenium import webdriver
 from selenium.webdriver.common.keys import Keys
 import time
 import unittest
 class NewVisitorTest(unittest.TestCase):
    def setUp(self):
        self.browser = webdriver.Firefox()
    def tearDown(self):
        self.browser.quit()
    def test_can_start_a_list_and_retrieve_it_later(self):
        # Edith has heard about a cool new online to-do app. She goes
        # to check out its homepage
        self.browser.get('http://localhost:8000')
        # She notices the page title and header mention to-do lists
        self.assertIn('To-Do', self.browser.title)
        header_text = self.browser.find_element_by_tag_name('h1').text
        self.assertIn('To-Do', header_text)
        # She is invited to enter a to-do item straight away
        inputbox = self.browser.find_element_by_id('id_new_item')
        self.assertEqual(
            inputbox.get_attribute('placeholder'),
            'Enter a to-do item'
        )
        # She types "Buy peacock feathers" into a text box (Edith's hobby
        # is tying fly-fishing lures)
        inputbox.send_keys('Buy peacock feathers')
        # When she hits enter, the page updates, and now the page lists
        # "1: Buy peacock feathers" as an item in a to-do list
        inputbox.send_keys(Keys.ENTER)
        time.sleep(1)
        table = self.browser.find_element_by_id('id_list_table')
        rows = table.find_element_by_tag_name('tr')
        self.assertTrue(
            any(row.text == '1: Buy peacock feathers' for row in rows)
        )
        # There is still a text box inviting her to add another item. She
        # enters "Use peacock feathers to make a fly" (Edith is very methodical)
        self.fail('Finish the test!')
        # The page updates again, and now shows both items on her list
        # Edith wonders whether the site will remember her list. Then she sees
        # that the site has generated a unique URL for her -- there is some
        # explanatory text to that effect.
        # She visits that URL - her to-do list is still there.
        # Satisfied, she goes back to sleep
 if __name__ == '__main__':
    unittest.main(warnings='ignore')
 ```
 Start django server and then run `python functional_tests.py`
 ## 4.3 The "Don't Test Constants" Rule, and Templates to the Rescue
 Our object: test HTML.
 Problem: currently test case look for exact HTML string, directly test content within HTML using fixed string is not wise.
 Testing content within a HTML is not useful, as it's testing constant.
 Unit tests are about testing **logic**, **flow control**, and **configuration**.
 Using template is much better solution to test raw strings in Python.
 ### 4.3.1 Refactoring to Use a Template
 Our object: refactor view function return the same HTML
 **Refactor** = improve the code *without changing its functionality*
 1. Create a html file in `lists/template` folder, in which Django look for template that used for the app
 2. django use `render` function to render the template, given request
 3. Add app into `superlists/settings.py`'s `INSTALLED_APPS` list, so django will search it
 Check commit 89224c9
 ### 4.3.2 The Django Test Client
 Django provides **Django Test Client** which can be used to check what templates are used.
 ```python
        request = HttpRequest() #1
        response = home_page(request) #2
 ```
 can be replaced by (django test client)
 ```python
        response = self.client.get('/') #1
 ```
 And assert methods
 ```python
        self.assertTrue(html.startswith('<html>'))
        self.assertIn('<title>To-Do lists</title>', html)
        self.assertTrue(html.strip().endswith('</html>'))
 ```
 can be replaced by 
 ```python
        self.assertTemplateUsed(response, 'home.html') #3
 ```
 Note: DJANGO TEST CLIENT is introduced until now because manual test steps are necessary for learning
 Check commit 747e0c7
 ## 4.4 On Refactoring
 Tip: **When refactoring, work on either the code or the tests, but not both at once**, otherwise, changing both will quickly lead to change across multiple files and chaos
 ## 4.5 A Little More of Our Front Page
 ## Recap: The TDD Process
 Main aspects of TDD process:
 * Functional tests
 * Unit tests
 * The unit-test/code cycle
 * Refactoring
 Overall TDD process is:
 ![TDD workflow](img/4-1.jpg)
 Ques: How does FT, UT cooperate with TDD?
 ANS: FT is a larger TDD cycle, while UTs are smaller TDD cycles
 1. Write a FT and see it fail.
 2. mini-TDD cycle of each unit test is employed to achieve small steps
 QUES: How does refactoring cooperate with TDD?
 ANS: Use a FT to check the behavior of app, FT is fixed but UTs can be add/removed
 Overall, it's a "Double-Loop TDD" as shown below
 ![Double-Loop TDD](img/4-2.jpg)
--- a/textbook/img/4-1
+++ b/textbook/img/4-1
--- a/textbook/img/4-1.jpg
+++ b/textbook/img/4-1.jpg
--- a/textbook/img/4-2.jpg
+++ b/textbook/img/4-2.jpg