├── .gitignore
├── Unit-01
    ├── 01-flask-intro
    │   ├── app.py
    │   ├── readme.md
    │   └── test.py
    ├── 02-flask-routing
    │   ├── app.py
    │   ├── readme.md
    │   └── test.py
    ├── 03-templating
    │   ├── app.py
    │   ├── readme.md
    │   └── test.py
    ├── 04-flask-crud
    │   ├── app.py
    │   ├── readme.md
    │   ├── snack.py
    │   └── test.py
    ├── 05-sql-flask
    │   ├── app.py
    │   ├── db.py
    │   ├── readme.md
    │   └── test.py
    ├── 06-sql-alchemy-1
    │   ├── readme.md
    │   └── test.py
    ├── 07-sql-alchemy-2
    │   ├── readme.md
    │   └── test.py
    ├── 08-testing
    │   └── readme.md
    └── 09-forms
    │   ├── readme.md
    │   └── test.py
├── Unit-02
    ├── 01-blueprints
    │   ├── readme.md
    │   └── test.py
    ├── 02-many-to-many
    │   ├── readme.md
    │   └── test.py
    ├── 03-hashing-sessions
    │   ├── readme.md
    │   └── test.py
    ├── 04-flask-login
    │   ├── readme.md
    │   └── test.py
    └── 05-oauth
    │   └── readme.md
└── readme.md


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | __pycache__
3 | *.db
4 | 


--------------------------------------------------------------------------------
/Unit-01/01-flask-intro/app.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rithmschool/python_curriculum_exercises/f68dacf80e1ee5688ff64973f9d875a1b0c82111/Unit-01/01-flask-intro/app.py


--------------------------------------------------------------------------------
/Unit-01/01-flask-intro/readme.md:
--------------------------------------------------------------------------------
 1 | # Flask Basics
 2 | 
 3 | For this assignment you will be creating a very small flask application. Your application should:
 4 | 
 5 | - have a route for `/welcome`, which responds with the string "welcome"
 6 | - have a route for `/welcome/home`, which responds with the string "welcome home"
 7 | - have a route for `/welcome/back`, which responds with the string "welcome back"
 8 | 
 9 | ### Bonus
10 | 
11 | Add another route to `/sum` and inside the function which sends a response, create a variable called `sum` which is equal to 5+5. Respond with the sum variable.
12 | 


--------------------------------------------------------------------------------
/Unit-01/01-flask-intro/test.py:
--------------------------------------------------------------------------------
 1 | from app import app
 2 | import unittest
 3 | 
 4 | class TestSimpleRoutes(unittest.TestCase):
 5 | 
 6 |     def test_welcome(self):
 7 |         tester = app.test_client(self)
 8 |         response = tester.get('/welcome', content_type='html/text')
 9 |         self.assertIn(b'welcome', response.data)
10 |         self.assertEqual(response.status_code, 200)
11 | 
12 |     def test_welcome_home(self):
13 |         tester = app.test_client(self)
14 |         response = tester.get('/welcome/home', content_type='html/text')
15 |         self.assertIn(b'welcome home', response.data)
16 |         self.assertEqual(response.status_code, 200)
17 | 
18 |     def test_welcome_back(self):
19 |         tester = app.test_client(self)
20 |         response = tester.get('/welcome/back', content_type='html/text')
21 |         self.assertIn(b'welcome back', response.data)
22 |         self.assertEqual(response.status_code, 200)
23 | 
24 |     def test_sum(self):
25 |         tester = app.test_client(self)
26 |         response = tester.get('/sum', content_type='html/text')
27 |         self.assertIn(b'10', response.data)
28 |         self.assertEqual(response.status_code, 200)
29 | 
30 | if __name__ == '__main__':
31 |     unittest.main()


--------------------------------------------------------------------------------
/Unit-01/02-flask-routing/app.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rithmschool/python_curriculum_exercises/f68dacf80e1ee5688ff64973f9d875a1b0c82111/Unit-01/02-flask-routing/app.py


--------------------------------------------------------------------------------
/Unit-01/02-flask-routing/readme.md:
--------------------------------------------------------------------------------
 1 | # Flask Routing
 2 | 
 3 | Build a simple calculator! You should have routes that can perform addition, subtraction, multiplication and division with two numbers so if a request is made to `/add/2/2` the server should respond with `4`.
 4 | 
 5 | ### Bonus
 6 | 
 7 | Refactor your code so that all of these operations can be done in a single route called `/math`
 8 | 
 9 | 
10 | 


--------------------------------------------------------------------------------
/Unit-01/02-flask-routing/test.py:
--------------------------------------------------------------------------------
 1 | from app import app
 2 | import unittest
 3 | 
 4 | class TestCalculator(unittest.TestCase):
 5 | 
 6 |     def test_add(self):
 7 |         tester = app.test_client(self)
 8 |         response = tester.get('/add/2/2', content_type='html/text')
 9 |         self.assertIn(b'4', response.data)
10 |         self.assertEqual(response.status_code, 200)
11 | 
12 |     def test_subtract(self):
13 |         tester = app.test_client(self)
14 |         response = tester.get('/subtract/2/2', content_type='html/text')
15 |         self.assertIn(b'0', response.data)
16 |         self.assertEqual(response.status_code, 200)
17 | 
18 |     def test_multiply(self):
19 |         tester = app.test_client(self)
20 |         response = tester.get('/multiply/20/2', content_type='html/text')
21 |         self.assertIn(b'40', response.data)
22 |         self.assertEqual(response.status_code, 200)
23 | 
24 |     def test_division(self):
25 |         tester = app.test_client(self)
26 |         response = tester.get('/divide/2/2', content_type='html/text')
27 |         self.assertIn(b'1', response.data)
28 |         self.assertEqual(response.status_code, 200)
29 | 
30 |     def test_all_in_one(self):
31 |         tester = app.test_client(self)
32 |         response = tester.get('/math/add/2/2', content_type='html/text')
33 |         self.assertIn(b'4', response.data)
34 |         self.assertEqual(response.status_code, 200)
35 | 
36 |         response = tester.get('/math/subtract/2/2', content_type='html/text')
37 |         self.assertIn(b'0', response.data)
38 |         self.assertEqual(response.status_code, 200)
39 | 
40 |         response = tester.get('/math/multiply/2/20', content_type='html/text')
41 |         self.assertIn(b'40', response.data)
42 |         self.assertEqual(response.status_code, 200)
43 | 
44 |         response = tester.get('/math/divide/2/2', content_type='html/text')
45 |         self.assertIn(b'1', response.data)
46 |         self.assertEqual(response.status_code, 200)
47 | 
48 | 
49 | if __name__ == '__main__':
50 |     unittest.main()


--------------------------------------------------------------------------------
/Unit-01/03-templating/app.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rithmschool/python_curriculum_exercises/f68dacf80e1ee5688ff64973f9d875a1b0c82111/Unit-01/03-templating/app.py


--------------------------------------------------------------------------------
/Unit-01/03-templating/readme.md:
--------------------------------------------------------------------------------
 1 | # Flask Templating
 2 | 
 3 | Create a new Flask application with the following:
 4 | 
 5 | ### Part 1
 6 | 
 7 | - A `base.html` template for others to inherit from
 8 | - A route for `/person/<name>/<age>` which renders a template that displays the name and age entered for the URL. That template should inherit from `base.html` 
 9 | 
10 | ### Part 2
11 | 
12 | Refactor your calculator application from before! 
13 | 
14 | - have a route for `/calculate` which renders a template called `calc.html`
15 | - in `calc.html`, build a form which has two inputs (one with a name of `num1` and another with the name of `num2`for numbers and a select field with the name of `calculation` with options for "add", "subract", "multiply" and "divide". 
16 | - When the form is submitted it should make a request to a route called `/math`
17 | - In your python file, accept the values from the form and depending on what the request contains, respond with the sum, difference, product or quotient.
18 | 
19 | ### Part 3
20 | 
21 | Create a small application which grabs headlines from Google News by keyword. (This application is based on the [Google News web scraper](https://www.rithmschool.com/courses/python-fundamentals-part-2/python-web-scraping-exercises) from the web scraping exercises.)
22 | 
23 | - This application should consist of two routes, `/` and `/results`
24 | - When the server receives a request to `/`, it should render an HTML page with a form prompting the user for a keyword (e.g. "California"). Submitting the form should result in a request to `/results`, with the form input passed in the [query string](https://en.wikipedia.org/wiki/Query_string).
25 | - When the server receives a request to `/results`, it should do the following:
26 |     1. Grab the keyword from the query string;
27 |     2. Make a request to `https://news.google.com`, and scrape the respose HTML for all news articles (links and headlines);
28 |     3. Filter out articles whose headlines do not match the keyword passed in from the query string;
29 |     4. Render an HTML page with matching articles (links and headlines) in a list.
30 | 
31 | 


--------------------------------------------------------------------------------
/Unit-01/03-templating/test.py:
--------------------------------------------------------------------------------
 1 | from app import app
 2 | import unittest
 3 | 
 4 | class TestTemplateRoutes(unittest.TestCase):
 5 | 
 6 |     def test_welcome(self):
 7 |         tester = app.test_client(self)
 8 |         response = tester.get('/person/bob/20', content_type='html/text')
 9 |         self.assertIn(b'bob', response.data)
10 |         self.assertIn(b'20', response.data)
11 | 
12 |         response = tester.get('/person/bob/20', content_type='html/text')
13 |         self.assertEqual(response.status_code, 200)
14 | 
15 |         response = tester.get('/person/bob', content_type='html/text')
16 |         self.assertEqual(response.status_code, 404)
17 | 
18 |         response = tester.get('/person', content_type='html/text')
19 |         self.assertEqual(response.status_code, 404)
20 | 
21 |     def test_calculate(self):
22 |         tester = app.test_client(self)
23 |         response = tester.get('/calculate', content_type='html/text')
24 |         self.assertIn(b'add', response.data)
25 |         self.assertIn(b'subtract', response.data)
26 |         self.assertIn(b'multiply', response.data)
27 |         self.assertIn(b'divide', response.data)
28 |         self.assertEqual(response.status_code, 200)
29 | 
30 |     def test_math(self):
31 |         tester = app.test_client(self)
32 |         response = tester.get('/math?num1=10&num2=20&calculation=add', content_type='html/text')
33 |         self.assertIn(b'30', response.data)
34 |         self.assertEqual(response.status_code, 200)
35 | 
36 |         response = tester.get('/math?num1=10&num2=20&calculation=subtract', content_type='html/text')
37 |         self.assertIn(b'-10', response.data)
38 |         self.assertEqual(response.status_code, 200)
39 | 
40 |         response = tester.get('/math?num1=10&num2=120&calculation=multiply', content_type='html/text')
41 |         self.assertIn(b'1200', response.data)
42 |         self.assertEqual(response.status_code, 200)
43 | 
44 |         response = tester.get('/math?num1=20&num2=20&calculation=divide', content_type='html/text')
45 |         self.assertIn(b'1', response.data)
46 |         self.assertEqual(response.status_code, 200)
47 | 
48 |     def test_index(self):
49 |         tester = app.test_client(self)
50 |         response = tester.get('/', content_type='html/text')
51 |         self.assertIn(b'<form', response.data)
52 |         self.assertEqual(response.status_code, 200)
53 | 
54 |     def test_results(self):
55 |         tester = app.test_client(self)
56 |         response = tester.get('/results', content_type='html/text', query_string={'keyword': 'the'})
57 |         keyword_count = response.data.count(b'the')
58 |         li_count = response.data.count(b'<li')
59 |         self.assertEqual(response.status_code, 200)
60 |         self.assertGreater(li_count, 0)
61 |         self.assertLessEqual(li_count, keyword_count)
62 | 
63 | if __name__ == '__main__':
64 |     unittest.main()


--------------------------------------------------------------------------------
/Unit-01/04-flask-crud/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask
2 | 
3 | snack_list = []


--------------------------------------------------------------------------------
/Unit-01/04-flask-crud/readme.md:
--------------------------------------------------------------------------------
 1 | # Flask CRUD
 2 | 
 3 | For this application you will be building CRUD on the resouce `snacks`. Your application should:
 4 | 
 5 | - display all the `snacks`
 6 | - allow a user to create `snacks` 
 7 |     -  each snack should have a `name` and `kind`
 8 | - allow a user to edit a snack
 9 | - allow a user to delete a snack
10 | 
11 | You should use a list to store your snacks and make a class for a snack to create instances from.
12 | 
13 | **BONUS** Make your app look amazing with some CSS!
14 | **BONUS** If you go to the show page for an invalid id, your applicaiton will break. Create a 404 page and redirect to it in the event that a user tries to go to the show or edit pages for a snack with an invalid id.
15 | 


--------------------------------------------------------------------------------
/Unit-01/04-flask-crud/snack.py:
--------------------------------------------------------------------------------
1 | # Add a class for a snack here!


--------------------------------------------------------------------------------
/Unit-01/04-flask-crud/test.py:
--------------------------------------------------------------------------------
 1 | from snack import Snack
 2 | from app import app, snack_list
 3 | import unittest
 4 | 
 5 | class TestSnackMethods(unittest.TestCase):
 6 | 
 7 |     def setUp(self):
 8 |         snack_list.append(Snack('snickers', 'chocolate'))
 9 |         snack_list.append(Snack('skittles', 'candy'))
10 | 
11 |     def tearDown(self):
12 |         snack_list.clear()
13 |         Snack.id = 1
14 | 
15 |     def test_index(self):
16 |         tester = app.test_client(self)
17 |         response = tester.get('/snacks', content_type='html/text')
18 |         self.assertEqual(response.status_code, 200)
19 | 
20 |     def test_new(self):
21 |         tester = app.test_client(self)
22 |         response = tester.get('/snacks/new', content_type='html/text')
23 |         self.assertEqual(response.status_code, 200)
24 | 
25 |     def test_edit(self):
26 |         tester = app.test_client(self)
27 |         response = tester.get('/snacks/1', content_type='html/text')
28 |         self.assertEqual(response.status_code, 200)
29 | 
30 |     def test_show(self):
31 |         tester = app.test_client(self)
32 |         response = tester.get('/snacks/1/edit', content_type='html/text')
33 |         self.assertEqual(response.status_code, 200)
34 | 
35 |     def test_creating_snack(self):
36 |       tester = app.test_client(self)
37 |       tester.post('/snacks',
38 |                         data=dict(name="hersheys", kind="chocolate"), follow_redirects = True)
39 |       self.assertEqual(snack_list[2].id, 3)
40 |       self.assertEqual(snack_list[2].name, 'hersheys')
41 |       self.assertEqual(snack_list[2].kind, 'chocolate')
42 |       self.assertEqual(len(snack_list), 3)
43 | 
44 |     def test_editing_snack(self):
45 |       tester = app.test_client(self)
46 |       tester.post('/snacks/1?_method=PATCH',
47 |                         data=dict(name="almond_snickers", kind="almonds_and_chocolate"), follow_redirects = True)
48 |       self.assertEqual(snack_list[0].name, 'almond_snickers')
49 |       self.assertEqual(snack_list[0].kind, 'almonds_and_chocolate')
50 |       self.assertEqual(len(snack_list), 2)
51 | 
52 |     def test_deleting_snack(self):
53 |       tester = app.test_client(self)
54 |       tester.post('/snacks/1?_method=DELETE', follow_redirects = True)
55 |       tester.post('/snacks/2?_method=DELETE', follow_redirects = True)
56 |       self.assertEqual(len(snack_list), 0)
57 | 
58 | if __name__ == '__main__':
59 |     unittest.main()
60 | 


--------------------------------------------------------------------------------
/Unit-01/05-sql-flask/app.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rithmschool/python_curriculum_exercises/f68dacf80e1ee5688ff64973f9d875a1b0c82111/Unit-01/05-sql-flask/app.py


--------------------------------------------------------------------------------
/Unit-01/05-sql-flask/db.py:
--------------------------------------------------------------------------------
 1 | import psycopg2
 2 | import psycopg2.extras
 3 | 
 4 | def connect():
 5 |     conn = psycopg2.connect("dbname=flask-sql-snacks")
 6 |     return conn
 7 | 
 8 | def create_table():
 9 |     conn = connect()
10 |     cur = conn.cursor()
11 |     cur.execute("CREATE TABLE IF NOT EXISTS snacks (id serial PRIMARY KEY, name text, kind text);")
12 |     conn.commit()
13 |     connect().close()
14 | 
15 | def close():
16 |     connect().close()
17 | 
18 | # Implement these methods!
19 | 
20 | def find_all_snacks():
21 |     pass
22 | 
23 | def create_snack(name, kind):
24 |     pass
25 | 
26 | def find_snack(id):
27 |     pass
28 | 
29 | def edit_snack(name, kind, id):
30 |     pass
31 | def remove_snack(id):
32 |     pass


--------------------------------------------------------------------------------
/Unit-01/05-sql-flask/readme.md:
--------------------------------------------------------------------------------
 1 | # SQL With Flask
 2 | 
 3 | For this application you will be refactoring CRUD on the resouce `snacks`. Instead of using a list, your application should use postgres and the `psycopg2` module! 
 4 | 
 5 | Make sure that you isolate your `psycopg2` related code into a file called `db.py` so that you do not have one large `app.py` file.
 6 | 
 7 | Make sure you create a database called `flask-sql-snacks` for your application and in order to run the tests, make sure you create a database called `flask-sql-snacks-test`
 8 | 
 9 | Your application should:
10 | 
11 | - display all the `snacks`
12 | - allow a user to create `snacks` 
13 |     -  each snack should have a `name` and `kind`
14 | - allow a user to edit a snack
15 | - allow a user to delete a snack
16 | 
17 | 


--------------------------------------------------------------------------------
/Unit-01/05-sql-flask/test.py:
--------------------------------------------------------------------------------
 1 | from app import app
 2 | from db import create_snack
 3 | from flask_testing import TestCase
 4 | import unittest
 5 | import psycopg2
 6 | 
 7 | class BaseTestCase(TestCase):
 8 |     def create_app(self):
 9 |         conn = psycopg2.connect("dbname=flask-sql-snacks-test")
10 |         cur = conn.cursor()
11 |         cur.execute("CREATE TABLE IF NOT EXISTS snacks (id serial PRIMARY KEY, name text, kind text);")
12 |         conn.commit()
13 |         conn.close()
14 |         return app
15 | 
16 |     def setUp(self):
17 |         create_snack("hershey", "chocolate")
18 | 
19 |     def tearDown(self):
20 |         conn = psycopg2.connect("dbname=flask-sql-snacks-test")
21 |         cur = conn.cursor()
22 |         cur.execute("DROP TABLE snacks;")
23 |         conn.commit()
24 |         conn.close()
25 | 
26 |     def test_index(self):
27 |         response = self.client.get('/snacks', content_type='html/text')
28 |         self.assertEqual(response.status_code, 200)
29 |         self.assertIn(b'hershey chocolate', response.data)
30 | 
31 |     def test_show(self):
32 |         response = self.client.get('/snacks/1')
33 |         self.assertEqual(response.status_code, 200)
34 | 
35 |     def test_create(self):
36 |         response = self.client.post(
37 |             '/snacks',
38 |             data=dict(name="New", kind="Snack"),
39 |             follow_redirects=True
40 |         )
41 |         self.assertIn(b'New Snack', response.data)
42 | 
43 |     def test_edit(self):
44 |         response = self.client.get(
45 |             '/snacks/1/edit'
46 |         )
47 |         self.assertIn(b'hershey', response.data)
48 |         self.assertIn(b'chocolate', response.data)
49 | 
50 |     def test_update(self):
51 |         response = self.client.post(
52 |             '/snacks/1?_method=PATCH',
53 |             data=dict(name="updated", kind="information"),
54 |             follow_redirects=True
55 |         )
56 |         self.assertIn(b'updated information', response.data)
57 |         self.assertNotIn(b'hershey chocolate', response.data)
58 | 
59 |     def test_delete(self):
60 |         response = self.client.post(
61 |             '/snacks/1?_method=DELETE',
62 |             follow_redirects=True
63 |         )
64 |         self.assertNotIn(b'hershey chocolate', response.data)
65 | 
66 | 
67 | if __name__ == '__main__':
68 |     unittest.main()
69 | 


--------------------------------------------------------------------------------
/Unit-01/06-sql-alchemy-1/readme.md:
--------------------------------------------------------------------------------
1 | # Flask-SQLAlchemy, Part I
2 | 
3 | It's time for more refactoring! This time, refactor your `snack` app to use Flask SQLAlchemy. You should have a `Snack` model to serve as an interface between instances in Python and rows in your `snacks` table.
4 | 
5 | ### Bonus
6 | 
7 | Research how to handle 404 errors using Flask-SQLAlchemy, and add a 404 page to your app that will get sent if someone tries to find a snack with an invalid id.


--------------------------------------------------------------------------------
/Unit-01/06-sql-alchemy-1/test.py:
--------------------------------------------------------------------------------
 1 | from app import app,db, Snack
 2 | from flask_testing import TestCase
 3 | import unittest
 4 | 
 5 | class BaseTestCase(TestCase):
 6 |     def create_app(self):
 7 |         app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///testing.db'
 8 |         return app
 9 | 
10 |     def setUp(self):
11 |         db.create_all()
12 |         snack1 = Snack("Hershey", "Chocolate")
13 |         snack2 = Snack("Skittles", "Candy")
14 |         snack3 = Snack("Chips Ahoy", "Cookie")
15 |         db.session.add_all([snack1, snack2, snack3])
16 |         db.session.commit()
17 | 
18 |     def tearDown(self):
19 |         db.drop_all()
20 | 
21 |     def test_index(self):
22 |         response = self.client.get('/snacks', content_type='html/text')
23 |         self.assertEqual(response.status_code, 200)
24 |         self.assertIn(b'Hershey Chocolate', response.data)
25 |         self.assertIn(b'Skittles Candy', response.data)
26 |         self.assertIn(b'Chips Ahoy Cookie', response.data)
27 | 
28 |     def test_show(self):
29 |         response = self.client.get('/snacks/1')
30 |         self.assertEqual(response.status_code, 200)
31 | 
32 |     def test_create(self):
33 |         response = self.client.post(
34 |             '/snacks',
35 |             data=dict(name="New", kind="Student"),
36 |             follow_redirects=True
37 |         )
38 |         self.assertIn(b'New Student', response.data)
39 | 
40 |     def test_edit(self):
41 |         response = self.client.get(
42 |             '/snacks/1/edit'
43 |         )
44 |         self.assertIn(b'Hershey', response.data)
45 |         self.assertIn(b'Chocolate', response.data)
46 | 
47 |     def test_update(self):
48 |         response = self.client.patch(
49 |             '/snacks/1',
50 |             data=dict(name="updated", kind="information"),
51 |             follow_redirects=True
52 |         )
53 |         self.assertIn(b'updated information', response.data)
54 |         self.assertNotIn(b'Hershey Chocolate', response.data)
55 | 
56 |     def test_delete(self):
57 |         response = self.client.delete(
58 |             '/snacks/1',
59 |             follow_redirects=True
60 |         )
61 |         self.assertNotIn(b'Hershey Chocolate', response.data)
62 | 
63 | 
64 | if __name__ == '__main__':
65 |     unittest.main()


--------------------------------------------------------------------------------
/Unit-01/07-sql-alchemy-2/readme.md:
--------------------------------------------------------------------------------
 1 | # Flask-SQLAlchemy, Part II
 2 | 
 3 | ### Part I - User
 4 | 
 5 | It's time to build a new application! This application should have full CRUD on the user resource. Each user should have a unique id, first_name, and last_name. You **must** have these fields for the test to pass.
 6 | 
 7 | ### Part II - Message
 8 | 
 9 | Now that you have one resource, it's time to add another! Each user should be able to write many messages. Each message should have a unique id and content. You **must** have these fields for the test to pass.
10 | 
11 | Your application should have RESTful routing and full CRUD on the User and Message resources. Remember that one user can send many messages. 
12 | 
13 | ### Bonuses
14 | 
15 | - Add styling to your application. Use Bootstrap or Bootswatch to help scaffold your design.
16 | - Handle 404 errors elegantly.
17 | - Add another column to users for an image_url. This way users can have their images show up in the application.
18 | - Implement a second one-to-many association in your app!
19 | 


--------------------------------------------------------------------------------
/Unit-01/07-sql-alchemy-2/test.py:
--------------------------------------------------------------------------------
  1 | from app import app,db, User, Message
  2 | from flask_testing import TestCase
  3 | import unittest
  4 | 
  5 | class BaseTestCase(TestCase):
  6 |     def create_app(self):
  7 |         app.config['WTF_CSRF_ENABLED'] = False
  8 |         app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///testing.db'
  9 |         return app
 10 | 
 11 |     def setUp(self):
 12 |         db.create_all()
 13 |         user1 = User("Elie", "Schoppik")
 14 |         user2 = User("Tim", "Garcia")
 15 |         user3 = User("Matt", "Lane")
 16 |         db.session.add_all([user1, user2, user3])
 17 |         message1 = Message("Hello Elie!!", 1)
 18 |         message2 = Message("Goodbye Elie!!", 1)
 19 |         message3 = Message("Hello Tim!!", 2)
 20 |         message4 = Message("Goodbye Tim!!", 2)
 21 |         db.session.add_all([message1, message2, message3,message4])
 22 |         db.session.commit()
 23 | 
 24 |     def tearDown(self):
 25 |         db.drop_all()
 26 | 
 27 |     def test_users_index(self):
 28 |         response = self.client.get('/users', content_type='html/text', follow_redirects=True)
 29 |         self.assertLess(response.status_code, 400)
 30 |         self.assertIn(b'Elie Schoppik', response.data)
 31 |         self.assertIn(b'Tim Garcia', response.data)
 32 |         self.assertIn(b'Matt Lane', response.data)
 33 | 
 34 |     def test_users_show(self):
 35 |         response = self.client.get('/users/1')
 36 |         self.assertEqual(response.status_code, 200)
 37 | 
 38 |     def test_users_create(self):
 39 |         response = self.client.post(
 40 |             '/users',
 41 |             data=dict(first_name="Awesome", last_name="Student"),
 42 |             follow_redirects=True
 43 |         )
 44 |         self.assertEqual(response.status_code, 200)
 45 |         self.assertIn(b'Awesome', response.data)
 46 | 
 47 |     def test_users_edit(self):
 48 |         response = self.client.get(
 49 |             '/users/1/edit'
 50 |         )
 51 |         self.assertIn(b'Elie', response.data)
 52 |         self.assertIn(b'Schoppik', response.data)
 53 | 
 54 |     def test_users_update(self):
 55 |         response = self.client.patch(
 56 |             '/users/1?_method=PATCH',
 57 |             data=dict(first_name="updated", last_name="information"),
 58 |             follow_redirects=True
 59 |         )
 60 |         self.assertIn(b'updated information', response.data)
 61 |         self.assertNotIn(b'Elie Schoppik', response.data)
 62 | 
 63 |     def test_users_delete(self):
 64 |         response = self.client.delete(
 65 |             '/users/1?_method=DELETE',
 66 |             follow_redirects=True
 67 |         )
 68 |         self.assertNotIn(b'Elie Schoppik', response.data)
 69 | 
 70 |     #### TESTS FOR MESSAGES ####
 71 | 
 72 |     def test_messages_index(self):
 73 |         response = self.client.get('/users/1/messages', content_type='html/text', follow_redirects=True)
 74 |         self.assertLess(response.status_code, 400)
 75 |         self.assertIn(b'Hello Elie!!', response.data)
 76 |         self.assertIn(b'Goodbye Elie!!', response.data)
 77 | 
 78 |     def test_messages_show(self):
 79 |         response = self.client.get('/users/1/messages/1')
 80 |         self.assertEqual(response.status_code, 200)
 81 | 
 82 |     def test_messages_create(self):
 83 |         response = self.client.post(
 84 |             '/users/1/messages',
 85 |             data=dict(content="Hi Matt!!", user_id=3),
 86 |             follow_redirects=True
 87 |         )
 88 |         self.assertEqual(response.status_code, 200)
 89 |         self.assertIn(b'Hi Matt!!', response.data)
 90 | 
 91 |     def test_messages_edit(self):
 92 |         response = self.client.get(
 93 |             '/users/1/messages/1/edit'
 94 |         )
 95 |         self.assertIn(b'Hello Elie!!', response.data)
 96 | 
 97 |         response = self.client.get(
 98 |             '/users/2/messages/4/edit'
 99 |         )
100 |         self.assertIn(b'Goodbye Tim!!', response.data)
101 | 
102 |     def test_messages_update(self):
103 |         response = self.client.patch(
104 |             '/users/1/messages/1?_method=PATCH',
105 |             data=dict(content="Welcome Back Elie!"),
106 |             follow_redirects=True
107 |         )
108 |         self.assertIn(b'Welcome Back Elie!', response.data)
109 | 
110 |     def test_messages_delete(self):
111 |         response = self.client.delete(
112 |             '/users/1/messages/1?_method=DELETE',
113 |             follow_redirects=True
114 |         )
115 |         self.assertNotIn(b'Hello Elie!!', response.data)
116 | 
117 | 
118 | if __name__ == '__main__':
119 |     unittest.main()
120 | 


--------------------------------------------------------------------------------
/Unit-01/08-testing/readme.md:
--------------------------------------------------------------------------------
 1 | # Testing Flask Application
 2 | 
 3 | It's time to add tests! Use Flask-testing to write tests for each CRUD on your users and messages app from the previous assignment. This includes writing tests for: 
 4 | 
 5 | - creating, reading, updating and deleting a user
 6 | - creating, reading, updating and deleting a message
 7 | 
 8 | **Bonuses**
 9 | 
10 | - Write tests for 404 errors
11 | - Write a test that ensures your edit form is prepopulated with a messages' current values
12 | - It would be weird if a user's `first_name` or `last_name` were empty. Write a test to make sure that neither is an empty string. Then write the code in your application to make the test pass!
13 | 


--------------------------------------------------------------------------------
/Unit-01/09-forms/readme.md:
--------------------------------------------------------------------------------
 1 | # WTForms
 2 | 
 3 | Refactor your User and Message application to use WTForms. Make sure your forms do the following
 4 | 
 5 | - Validate that each user has a `first_name` and `last_name`
 6 | - Validate that each message has a `content`
 7 | - have `csrf` protection
 8 | 
 9 | ### Bonus
10 | 
11 | Add client side validation! Use JavaScript to stop users from submitting from submitting forms if their data is incorrect. Try to even alert users before they submit the form using keypress events!
12 | 


--------------------------------------------------------------------------------
/Unit-01/09-forms/test.py:
--------------------------------------------------------------------------------
  1 | from app import app,db, User, Message
  2 | from flask_testing import TestCase
  3 | import unittest
  4 | 
  5 | class BaseTestCase(TestCase):
  6 |     def create_app(self):
  7 |         app.config['WTF_CSRF_ENABLED'] = False
  8 |         app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///testing.db'
  9 |         return app
 10 | 
 11 |     def setUp(self):
 12 |         db.create_all()
 13 |         user1 = User("Elie", "Schoppik")
 14 |         user2 = User("Tim", "Garcia")
 15 |         user3 = User("Matt", "Lane")
 16 |         db.session.add_all([user1, user2, user3])
 17 |         message1 = Message("Hello Elie!!", 1)
 18 |         message2 = Message("Goodbye Elie!!", 1)
 19 |         message3 = Message("Hello Tim!!", 2)
 20 |         message4 = Message("Goodbye Tim!!", 2)
 21 |         db.session.add_all([message1, message2, message3,message4])
 22 |         db.session.commit()
 23 | 
 24 |     def tearDown(self):
 25 |         db.drop_all()
 26 | 
 27 |     def test_users_index(self):
 28 |         response = self.client.get('/users', content_type='html/text', follow_redirects=True)
 29 |         self.assertLess(response.status_code, 400)
 30 |         self.assertIn(b'Elie Schoppik', response.data)
 31 |         self.assertIn(b'Tim Garcia', response.data)
 32 |         self.assertIn(b'Matt Lane', response.data)
 33 | 
 34 |     def test_users_show(self):
 35 |         response = self.client.get('/users/1')
 36 |         self.assertEqual(response.status_code, 200)
 37 | 
 38 |     def test_users_create_correctly(self):
 39 |         response = self.client.post(
 40 |             '/users',
 41 |             data=dict(first_name="Awesome", last_name="Student"),
 42 |             follow_redirects=True
 43 |         )
 44 |         self.assertEqual(response.status_code, 200)
 45 |         self.assertIn(b'Awesome', response.data)
 46 | 
 47 |     def test_users_create_incorrectly(self):
 48 |         response = self.client.post(
 49 |             '/users',
 50 |             data=dict(first_name="", last_name="Student"),
 51 |             follow_redirects=True
 52 |         )
 53 |         self.assertEqual(response.status_code, 200)
 54 |         self.assertIn(b'This field is required', response.data)
 55 | 
 56 |     def test_users_edit(self):
 57 |         response = self.client.get(
 58 |             '/users/1/edit'
 59 |         )
 60 |         self.assertIn(b'Elie', response.data)
 61 |         self.assertIn(b'Schoppik', response.data)
 62 | 
 63 |     def test_users_update(self):
 64 |         response = self.client.patch(
 65 |             '/users/1?_method=PATCH',
 66 |             data=dict(first_name="updated", last_name="information"),
 67 |             follow_redirects=True
 68 |         )
 69 |         self.assertIn(b'updated information', response.data)
 70 |         self.assertNotIn(b'Elie Schoppik', response.data)
 71 | 
 72 |     def test_users_delete(self):
 73 |         response = self.client.delete(
 74 |             '/users/1?_method=DELETE',
 75 |             follow_redirects=True
 76 |         )
 77 |         self.assertNotIn(b'Elie Schoppik', response.data)
 78 | 
 79 |     #### TESTS FOR MESSAGES ####
 80 | 
 81 |     def test_messages_index(self):
 82 |         response = self.client.get('/users/1/messages', content_type='html/text', follow_redirects=True)
 83 |         self.assertLess(response.status_code, 400)
 84 |         self.assertIn(b'Hello Elie!!', response.data)
 85 |         self.assertIn(b'Goodbye Elie!!', response.data)
 86 | 
 87 |     def test_messages_show(self):
 88 |         response = self.client.get('/users/1/messages/1')
 89 |         self.assertEqual(response.status_code, 200)
 90 | 
 91 |     def test_messages_create_correctly(self):
 92 |         response = self.client.post(
 93 |             '/users/1/messages',
 94 |             data=dict(content="Hi Matt!!", user_id=3),
 95 |             follow_redirects=True
 96 |         )
 97 |         self.assertEqual(response.status_code, 200)
 98 |         self.assertIn(b'Hi Matt!!', response.data)
 99 | 
100 |     def test_messages_create_incorrectly(self):
101 |         response = self.client.post(
102 |             '/users/1/messages',
103 |             data=dict(content=""),
104 |             follow_redirects=True
105 |         )
106 |         self.assertEqual(response.status_code, 200)
107 |         self.assertIn(b'This field is required', response.data)
108 | 
109 |     def test_messages_edit(self):
110 |         response = self.client.get(
111 |             '/users/1/messages/1/edit'
112 |         )
113 |         self.assertIn(b'Hello Elie!!', response.data)
114 | 
115 |         response = self.client.get(
116 |             '/users/2/messages/4/edit'
117 |         )
118 |         self.assertIn(b'Goodbye Tim!!', response.data)
119 | 
120 |     def test_messages_update(self):
121 |         response = self.client.patch(
122 |             '/users/1/messages/1?_method=PATCH',
123 |             data=dict(content="Welcome Back Elie!"),
124 |             follow_redirects=True
125 |         )
126 |         self.assertIn(b'Welcome Back Elie!', response.data)
127 | 
128 |     def test_messages_delete(self):
129 |         response = self.client.delete(
130 |             '/users/1/messages/1?_method=DELETE',
131 |             follow_redirects=True
132 |         )
133 |         self.assertNotIn(b'Hello Elie!!', response.data)
134 | 
135 | 
136 | if __name__ == '__main__':
137 |     unittest.main()
138 | 


--------------------------------------------------------------------------------
/Unit-02/01-blueprints/readme.md:
--------------------------------------------------------------------------------
 1 | # Blueprints 
 2 | 
 3 | ### Part I - Questions
 4 | 
 5 | 1. Describe the MVC pattern.
 6 | 2. In the MVC pattern, does the model communicate directly with the view?
 7 | 2. What is the purpose of blueprints?
 8 | 3. How does using blueprints help us organize bigger applications?
 9 | 
10 | ### Part II - Exercise
11 | 
12 | 1. Refactor your users and messages app to use blueprints.  Make sure to have a separate file for `models.py`, `views.py`, and `forms.py`. You should have a working 1 to Many application with blueprints when this exercise is complete!
13 | 
14 | 2. Include the following flash messages (it's important you make sure these are exact so the tests will pass)
15 |     - when a user is created, send a flash message of "User Created!"
16 |     - when a user is updated, send a flash message of "User Updated!"
17 |     - when a user is deleted, send a flash message of "User Deleted!"
18 |     - when a message is created, send a flash message of "Message Created!"
19 |     - when a message is updated, send a flash message of "Message Updated!"
20 |     - when a message is deleted, send a flash message of "Message Deleted!"
21 | 
22 | 3. If you have not added any styling or testing to your users and messages app, be sure to do so!
23 | 


--------------------------------------------------------------------------------
/Unit-02/01-blueprints/test.py:
--------------------------------------------------------------------------------
  1 | from project import app,db
  2 | from project.users.models import User
  3 | from project.messages.models import Message
  4 | from flask_testing import TestCase
  5 | import unittest
  6 | 
  7 | class BaseTestCase(TestCase):
  8 |     def create_app(self):
  9 |         app.config['WTF_CSRF_ENABLED'] = False
 10 |         app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///testing.db'
 11 |         return app
 12 | 
 13 |     def setUp(self):
 14 |         db.create_all()
 15 |         user1 = User("Elie", "Schoppik")
 16 |         user2 = User("Tim", "Garcia")
 17 |         user3 = User("Matt", "Lane")
 18 |         db.session.add_all([user1, user2, user3])
 19 |         message1 = Message("Hello Elie!!", 1)
 20 |         message2 = Message("Goodbye Elie!!", 1)
 21 |         message3 = Message("Hello Tim!!", 2)
 22 |         message4 = Message("Goodbye Tim!!", 2)
 23 |         db.session.add_all([message1, message2, message3,message4])
 24 |         db.session.commit()
 25 | 
 26 |     def tearDown(self):
 27 |         db.drop_all()
 28 | 
 29 |     def test_users_index(self):
 30 |         response = self.client.get('/users', content_type='html/text', follow_redirects=True)
 31 |         self.assertLess(response.status_code, 400)
 32 |         self.assertIn(b'Elie Schoppik', response.data)
 33 |         self.assertIn(b'Tim Garcia', response.data)
 34 |         self.assertIn(b'Matt Lane', response.data)
 35 | 
 36 |     def test_users_show(self):
 37 |         response = self.client.get('/users/1')
 38 |         self.assertEqual(response.status_code, 200)
 39 | 
 40 |     def test_users_create(self):
 41 |         response = self.client.post(
 42 |             '/users/',
 43 |             data=dict(first_name="Awesome", last_name="Student"),
 44 |             follow_redirects=True
 45 |         )
 46 |         self.assertEqual(response.status_code, 200)
 47 |         self.assertIn(b'Awesome', response.data)
 48 |         self.assertIn(b'User Created!', response.data)
 49 | 
 50 |     def test_users_edit(self):
 51 |         response = self.client.get(
 52 |             '/users/1/edit'
 53 |         )
 54 |         self.assertIn(b'Elie', response.data)
 55 |         self.assertIn(b'Schoppik', response.data)
 56 | 
 57 |     def test_users_update(self):
 58 |         response = self.client.patch(
 59 |             '/users/1?_method=PATCH',
 60 |             data=dict(first_name="updated", last_name="information"),
 61 |             follow_redirects=True
 62 |         )
 63 |         self.assertIn(b'updated information', response.data)
 64 |         self.assertNotIn(b'Elie Schoppik', response.data)
 65 | 
 66 |     def test_users_delete(self):
 67 |         response = self.client.delete(
 68 |             '/users/1?_method=DELETE',
 69 |             follow_redirects=True
 70 |         )
 71 |         self.assertNotIn(b'Elie Schoppik', response.data)
 72 | 
 73 |     #### TESTS FOR MESSAGES ####
 74 | 
 75 |     def test_messages_index(self):
 76 |         response = self.client.get('/users/1/messages', content_type='html/text', follow_redirects=True)
 77 |         self.assertLess(response.status_code, 400)
 78 |         self.assertIn(b'Hello Elie!!', response.data)
 79 |         self.assertIn(b'Goodbye Elie!!', response.data)
 80 | 
 81 |     def test_messages_show(self):
 82 |         response = self.client.get('/users/1/messages/1')
 83 |         self.assertEqual(response.status_code, 200)
 84 | 
 85 |     def test_messages_create(self):
 86 |         response = self.client.post(
 87 |             '/users/1/messages/',
 88 |             data=dict(text="Hi Matt!!", user_id=3),
 89 |             follow_redirects=True
 90 |         )
 91 |         self.assertEqual(response.status_code, 200)
 92 |         self.assertIn(b'Hi Matt!!', response.data)
 93 | 
 94 |     def test_messages_edit(self):
 95 |         response = self.client.get(
 96 |             '/users/1/messages/1/edit'
 97 |         )
 98 |         self.assertIn(b'Hello Elie!!', response.data)
 99 | 
100 |         response = self.client.get(
101 |             '/users/2/messages/4/edit'
102 |         )
103 |         self.assertIn(b'Goodbye Tim!!', response.data)
104 | 
105 |     def test_messages_update(self):
106 |         response = self.client.patch(
107 |             '/users/1/messages/1?_method=PATCH',
108 |             data=dict(text="Welcome Back Elie!"),
109 |             follow_redirects=True
110 |         )
111 |         self.assertIn(b'Welcome Back Elie!', response.data)
112 | 
113 |     def test_messages_delete(self):
114 |         response = self.client.delete(
115 |             '/users/1/messages/1?_method=DELETE',
116 |             follow_redirects=True
117 |         )
118 |         self.assertNotIn(b'Hello Elie!!', response.data)
119 | 
120 | 
121 | if __name__ == '__main__':
122 |     unittest.main()
123 | 


--------------------------------------------------------------------------------
/Unit-02/02-many-to-many/readme.md:
--------------------------------------------------------------------------------
 1 | # Many to Many
 2 | 
 3 | ### Part 1 
 4 | 
 5 | 1. Finish building CRUD in the many to many application with employees and departments. You can find the starter code [here](https://github.com/rithmschool/flask-many-many-example)
 6 | 
 7 | Your app should have the following features:
 8 | 
 9 | * Full CRUD on employees
10 | * Full CRUD on departments 
11 | * The index or show page for employees should show the department name for each employee
12 | * The index or show page for departments should show all employees in the department
13 | * Use WTForms for all CRUD operations for both employees and departments 
14 | 
15 | ### Part 2 
16 | 
17 | Add another resource to your users and messages application! Create a resource for tags which has a many to many relationship with messages. 
18 | 
19 | - You should be able to create full CRUD on tags 
20 | - When you create a message, you should be able to add existing tags to it. 
21 | - When you edit a message, you should be able to modify the tags associated to it. 
22 | - When you create a tag, you should be able to add existing messages to it.
23 | - When you edit a tag, you should be able to modify the messages associated to it. 
24 | 


--------------------------------------------------------------------------------
/Unit-02/02-many-to-many/test.py:
--------------------------------------------------------------------------------
  1 | from project import app,db
  2 | from project.models import User,Message
  3 | from flask_testing import TestCase
  4 | import unittest
  5 | 
  6 | class BaseTestCase(TestCase):
  7 |     def create_app(self):
  8 |         app.config['WTF_CSRF_ENABLED'] = False
  9 |         app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///testing.db'
 10 |         return app
 11 | 
 12 |     def setUp(self):
 13 |         db.create_all()
 14 |         user1 = User("Elie", "Schoppik")
 15 |         user2 = User("Tim", "Garcia")
 16 |         user3 = User("Matt", "Lane")
 17 |         db.session.add_all([user1, user2, user3])
 18 |         message1 = Message("Hello Elie!!", 1)
 19 |         message2 = Message("Goodbye Elie!!", 1)
 20 |         message3 = Message("Hello Tim!!", 2)
 21 |         message4 = Message("Goodbye Tim!!", 2)
 22 |         db.session.add_all([message1, message2, message3,message4])
 23 |         db.session.commit()
 24 | 
 25 |     def tearDown(self):
 26 |         db.drop_all()
 27 | 
 28 |     def test_users_index(self):
 29 |         response = self.client.get('/users', content_type='html/text', follow_redirects=True)
 30 |         self.assertLess(response.status_code, 400)
 31 |         self.assertIn(b'Elie Schoppik', response.data)
 32 |         self.assertIn(b'Tim Garcia', response.data)
 33 |         self.assertIn(b'Matt Lane', response.data)
 34 | 
 35 |     def test_users_show(self):
 36 |         response = self.client.get('/users/1')
 37 |         self.assertEqual(response.status_code, 200)
 38 | 
 39 |     def test_users_create(self):
 40 |         response = self.client.post(
 41 |             '/users/',
 42 |             data=dict(first_name="Awesome", last_name="Student"),
 43 |             follow_redirects=True
 44 |         )
 45 |         self.assertEqual(response.status_code, 200)
 46 |         self.assertIn(b'Awesome', response.data)
 47 |         self.assertIn(b'User Created!', response.data)
 48 | 
 49 |     def test_users_edit(self):
 50 |         response = self.client.get(
 51 |             '/users/1/edit'
 52 |         )
 53 |         self.assertIn(b'Elie', response.data)
 54 |         self.assertIn(b'Schoppik', response.data)
 55 | 
 56 |     def test_users_update(self):
 57 |         response = self.client.patch(
 58 |             '/users/1?_method=PATCH',
 59 |             data=dict(first_name="updated", last_name="information"),
 60 |             follow_redirects=True
 61 |         )
 62 |         self.assertIn(b'updated information', response.data)
 63 |         self.assertNotIn(b'Elie Schoppik', response.data)
 64 | 
 65 |     def test_users_delete(self):
 66 |         response = self.client.delete(
 67 |             '/users/1?_method=DELETE',
 68 |             follow_redirects=True
 69 |         )
 70 |         self.assertNotIn(b'Elie Schoppik', response.data)
 71 | 
 72 |     #### TESTS FOR MESSAGES ####
 73 | 
 74 |     def test_messages_index(self):
 75 |         response = self.client.get('/users/1/messages', content_type='html/text', follow_redirects=True)
 76 |         self.assertLess(response.status_code, 400)
 77 |         self.assertIn(b'Hello Elie!!', response.data)
 78 |         self.assertIn(b'Goodbye Elie!!', response.data)
 79 | 
 80 |     def test_messages_show(self):
 81 |         response = self.client.get('/users/1/messages/1')
 82 |         self.assertEqual(response.status_code, 200)
 83 | 
 84 |     def test_messages_create(self):
 85 |         response = self.client.post(
 86 |             '/users/1/messages/',
 87 |             data=dict(text="Hi Matt!!", user_id=3),
 88 |             follow_redirects=True
 89 |         )
 90 |         self.assertEqual(response.status_code, 200)
 91 | 
 92 |     def test_messages_edit(self):
 93 |         response = self.client.get(
 94 |             '/users/1/messages/1/edit'
 95 |         )
 96 |         self.assertIn(b'Hello Elie!!', response.data)
 97 | 
 98 |         response = self.client.get(
 99 |             '/users/2/messages/4/edit'
100 |         )
101 |         self.assertIn(b'Goodbye Tim!!', response.data)
102 | 
103 |     def test_messages_update(self):
104 |         response = self.client.patch(
105 |             '/users/1/messages/1?_method=PATCH',
106 |             data=dict(text="Welcome Back Elie!"),
107 |             follow_redirects=True
108 |         )
109 |         self.assertEqual(response.status_code, 200)
110 | 
111 |     def test_messages_delete(self):
112 |         response = self.client.delete(
113 |             '/users/1/messages/1?_method=DELETE',
114 |             follow_redirects=True
115 |         )
116 |         self.assertNotIn(b'Hello Elie!!', response.data)
117 | 
118 | 
119 | if __name__ == '__main__':
120 |     unittest.main()
121 | 


--------------------------------------------------------------------------------
/Unit-02/03-hashing-sessions/readme.md:
--------------------------------------------------------------------------------
 1 | # Hashing-Sessions
 2 | 
 3 | ### Part 1
 4 | 
 5 | Continue building on the simple authentication app from the Cookies and Sessions section (https://www.rithmschool.com/courses/intermediate-flask/cookies-sessions-flask). Add a `show` page and an `edit` page for your users. Make it so that you can view any user's show page, provided you're logged in, but you can only access your own edit page, not anyone else's.
 6 | 
 7 | ### Part 2
 8 | 
 9 | Add authentication to your users and messages application! You should also have an additional route:
10 | 
11 | `GET /messages` - shows all of the messages for every user - a user does not need to be logged in to see this content.
12 | 
13 | - Make sure that users can not create, edit or delete other users AND that users can not create, edit or delete messages for other users! This will require you to write some custom decorators so you can successfully implement authorization. 
14 | 


--------------------------------------------------------------------------------
/Unit-02/03-hashing-sessions/test.py:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | from flask_testing import TestCase
  3 | from project import app, db, bcrypt
  4 | from project.models import User, Message
  5 | from flask import request, g, session
  6 | 
  7 | class TestUser(TestCase):
  8 | 
  9 |     def _login_user(self,username,password,follow_redirects=False):
 10 |         return self.client.post('/users/login',
 11 |             data=dict(username=username,
 12 |             password=password), follow_redirects=follow_redirects)
 13 | 
 14 |     def create_app(self):
 15 |         app.config["WTF_CSRF_ENABLED"] = False
 16 |         app.config["SQLALCHEMY_ECHO"] = False
 17 |         app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///usersmessages.db'
 18 |         return app
 19 | 
 20 |     def setUp(self):
 21 |         """Disable CSRF, initialize a sqlite DB and seed a user"""
 22 |         db.create_all()
 23 |         user = User("Elie", "Schoppik","eschoppik", "secret")
 24 |         db.session.add(user)
 25 |         db.session.commit()
 26 | 
 27 |     def tearDown(self):
 28 |         """drop the db after each test"""
 29 |         db.drop_all()
 30 | 
 31 |     def test_user_registeration(self):
 32 |         """Ensure user can register"""
 33 |         with self.client:
 34 |             response = self.client.post('/users/signup', data=dict(
 35 |                 username='tigarcia',password='secret',first_name="Tim",last_name="Garcia"
 36 |             ), follow_redirects=True)
 37 |             self.assertIn(b'User Created!', response.data)
 38 |             self.assertEqual(g.current_user.username, "tigarcia")
 39 |             # make sure we hash the password!
 40 |             self.assertNotEqual(g.current_user.password, "secret")
 41 | 
 42 |     def test_incorrect_user_registeration_duplicate_username(self):
 43 |         """ Errors are thrown during an incorrect user registration"""
 44 |         with self.client:
 45 |             response = self.client.post('/users/signup', data=dict(
 46 |                 username='eschoppik',password='doesnotmatter',first_name="anything",last_name="anything@gmail.com"))
 47 |             self.assertIn(b'Username already taken', response.data)
 48 |             self.assertIn('/users/signup', request.url)
 49 | 
 50 |     def test_get_by_id(self):
 51 |         """Ensure id is correct for the current/logged in user"""
 52 |         with self.client:
 53 |             self.client.post('/users/login', data=dict(
 54 |                 username="eschoppik", password='secret'
 55 |             ), follow_redirects=True)
 56 |             self.assertTrue(g.current_user.id == 1)
 57 |             self.assertFalse(g.current_user.id == 20)
 58 | 
 59 |     def test_check_password(self):
 60 |         """ Ensure given password is correct after unhashing """
 61 |         user = User.query.filter_by(username='eschoppik').first()
 62 |         self.assertTrue(bcrypt.check_password_hash(user.password, 'secret'))
 63 |         self.assertFalse(bcrypt.check_password_hash(user.password, 'notsecret'))
 64 | 
 65 |     def test_login_page_loads(self):
 66 |         """Ensure that the login page loads correctly"""
 67 |         response = self.client.get('/users/login')
 68 |         self.assertIn(b'Login', response.data)
 69 | 
 70 |     def test_correct_login(self):
 71 |         """User should be authenticated upon successful login and stored in current user"""
 72 |         with self.client:
 73 |             response = self.client.post(
 74 |                 '/users/login',
 75 |                 data=dict(username="eschoppik", password="secret"),
 76 |                 follow_redirects=True
 77 |             )
 78 |             self.assertIn(b'You are now logged in!', response.data)
 79 | 
 80 | 
 81 |     def test_current_user(self):
 82 |         """A current_user variable is created on g when a user is logged in"""
 83 |         with self.client:
 84 |             self._login_user('eschoppik','secret', True)
 85 |             self.assertEqual(g.current_user.username, "eschoppik")
 86 | 
 87 |     def test_incorrect_login(self):
 88 |         """The correct flash message is sent when incorrect info is posted"""
 89 |         response = self.client.post(
 90 |             '/users/login',
 91 |             data=dict(username="dsadsa", password="dsadsadsa"),
 92 |             follow_redirects=True
 93 |         )
 94 |         self.assertIn(b"Invalid Credentials", response.data)
 95 | 
 96 |     def test_logout(self):
 97 |         """Make sure log out actually logs out a user"""
 98 |         with self.client:
 99 |             self.client.post(
100 |                 '/users/login',
101 |                 data=dict(username="eschoppik", password="secret"),
102 |                 follow_redirects=True
103 |             )
104 |             response = self.client.get('/users/logout', follow_redirects=True)
105 |             self.assertIn(b'Logged Out!', response.data)
106 | 
107 |     def test_logout_route_requires_login(self):
108 |         """Make sure that you can not log out without being logged in"""
109 |         response = self.client.get('/users/logout', follow_redirects=True)
110 |         self.assertIn(b'Please log in first', response.data)
111 | 
112 |     def testEditPassword(self):
113 |         """Logged In User Editing Password"""
114 |         self._login_user('eschoppik','secret')
115 |         response = self.client.post('/users/1?_method=PATCH',
116 |             data=dict(first_name='a', last_name='b',
117 |             username='bob', password='secret'), follow_redirects=True)
118 |         user = User.query.filter_by(username='bob').first()
119 |         self.assertEqual(response.status_code, 200)
120 |         self.assertEqual(bcrypt.check_password_hash(user.password, 'secret'),True)
121 | 
122 |     def test_add_messages(self):
123 |         """Ensure user can add a message"""
124 |         with self.client:
125 |             self._login_user('eschoppik','secret', follow_redirects=True)
126 |             response = self.client.post('/users/1/messages/', data=dict(content='Hello World',user_id=session.get('user_id')), follow_redirects=True)
127 |             self.assertIn(b'Message Created!', response.data)
128 |             message = Message.query.filter_by(content="Hello World").first()
129 |             self.assertEqual(message.user.first_name, "Elie")
130 |             self.assertEqual(message.content,"Hello World")
131 | 
132 |     def test_edit_messages(self):
133 |         """Ensure user can edit a message"""
134 |         with self.client:
135 |             self._login_user('eschoppik','secret')
136 |             self.client.post('/users/1/messages/', data=dict(content='Hello World',user_id=session.get('user_id'), follow_redirects=True))
137 |             response = self.client.post('/users/1/messages/1?_method=PATCH' , data= dict(
138 |                 content="Hello Everyone", user_id=session.get('user_id')
139 |             ), follow_redirects=True)
140 |             self.assertIn(b'Message Updated!', response.data)
141 |             message = Message.query.filter_by(content="Hello Everyone").first()
142 |             self.assertTrue(message.content == "Hello Everyone")
143 |             self.assertTrue(message.user_id == session.get('user_id'))
144 | 
145 |     def test_delete_message(self):
146 |         """Ensure user can delete a message"""
147 |         with self.client:
148 |             self._login_user('eschoppik','secret')
149 |             self.client.post('/users/1/messages/', data=dict(content='Hello World',user_id=session.get('user_id'), follow_redirects=True))
150 |             response = self.client.post('/users/1/messages/1?_method=DELETE', follow_redirects=True)
151 |             self.assertIn(b'Message Deleted!', response.data)
152 |             message = Message.query.filter_by(content="Hello World").first()
153 |             self.assertFalse(message)
154 | 
155 |     def test_cannot_modify_another_users_message(self):
156 |         """Ensure user can't edit another user's messages"""
157 |         with self.client:
158 |             self._login_user('eschoppik','secret')
159 |             self.client.post('/users/1/messages', data=dict(content='Hello World',user_id=session.get('user_id'), follow_redirects=True))
160 |             user2 = User("Another", "User", "secret", "secret")
161 |             db.session.add(user2)
162 |             db.session.commit()
163 |             self.client.get('/users/logout', follow_redirects=True)
164 |             self._login_user('secret','secret')
165 |             response = self.client.post('/users/1/messages/1?_method=PATCH' , data= dict(
166 |                 text="Here are updated comments.", user_id=session.get('user_id')
167 |             ), follow_redirects=True)
168 |             self.assertIn(b'Not Authorized', response.data)
169 | 
170 |     def test_cannot_delete_another_users_message(self):
171 |         """Ensure user can't delete another user's messages"""
172 |         with self.client:
173 |             self._login_user('eschoppik','secret')
174 |             self.client.post('/users/1/messages', data=dict(content='Hello World',user_id=session.get('user_id'), follow_redirects=True))
175 |             user2 = User("Another", "User", "secret", "secret")
176 |             db.session.add(user2)
177 |             db.session.commit()
178 |             self.client.get('/users/logout', follow_redirects=True)
179 |             self._login_user('secret','secret')
180 |             response = self.client.post('/users/1/messages/1?_method=DELETE', follow_redirects=True)
181 |             self.assertIn(b'Not Authorized', response.data)
182 | 
183 | if __name__ == '__main__':
184 |     unittest.main()
185 | 


--------------------------------------------------------------------------------
/Unit-02/04-flask-login/readme.md:
--------------------------------------------------------------------------------
1 | # Flask Login
2 | 
3 | Refactor your users and messages application to use flask_login! This should not be a terribly long refactor so now is a great time to go back and add some more testing and styling to your application! 
4 | 


--------------------------------------------------------------------------------
/Unit-02/04-flask-login/test.py:
--------------------------------------------------------------------------------
  1 | import unittest
  2 | from flask_testing import TestCase
  3 | from project import app, db, bcrypt
  4 | from project.models import User, Message
  5 | from flask import request
  6 | from flask_login import current_user
  7 | 
  8 | class TestUser(TestCase):
  9 | 
 10 |     def _login_user(self,username,password,follow_redirects=False):
 11 |         return self.client.post('/users/login',
 12 |             data=dict(username=username,
 13 |             password=password), follow_redirects=follow_redirects)
 14 | 
 15 |     def create_app(self):
 16 |         app.config["WTF_CSRF_ENABLED"] = False
 17 |         app.config["SQLALCHEMY_ECHO"] = False
 18 |         app.config["SQLALCHEMY_DATABASE_URI"] = 'sqlite:///dope.db'
 19 |         return app
 20 | 
 21 |     def setUp(self):
 22 |         """Disable CSRF, initialize a sqlite DB and seed a user"""
 23 |         db.create_all()
 24 |         user = User("Elie", "Schoppik","eschoppik", "secret")
 25 |         db.session.add(user)
 26 |         db.session.commit()
 27 | 
 28 |     def tearDown(self):
 29 |         """drop the db after each test"""
 30 |         db.drop_all()
 31 | 
 32 |     def test_user_registeration(self):
 33 |         """Ensure user can register"""
 34 |         with self.client:
 35 |             response = self.client.post('/users/signup', data=dict(
 36 |                 username='tigarcia',password='secret',first_name="Tim",last_name="Garcia"
 37 |             ), follow_redirects=True)
 38 |             self.assertIn(b'User Created!', response.data)
 39 |             self.assertEqual(current_user.username, "tigarcia")
 40 |             # make sure we hash the password!
 41 |             self.assertNotEqual(current_user.password, "secret")
 42 | 
 43 |     def test_incorrect_user_registeration_duplicate_username(self):
 44 |         """ Errors are thrown during an incorrect user registration"""
 45 |         with self.client:
 46 |             response = self.client.post('/users/signup', data=dict(
 47 |                 username='eschoppik',password='doesnotmatter',first_name="anything",last_name="anything@gmail.com"))
 48 |             self.assertIn(b'Username already taken', response.data)
 49 |             self.assertIn('/users/signup', request.url)
 50 | 
 51 |     def test_get_by_id(self):
 52 |         """Ensure id is correct for the current/logged in user"""
 53 |         with self.client:
 54 |             self.client.post('/users/login', data=dict(
 55 |                 username="eschoppik", password='secret'
 56 |             ), follow_redirects=True)
 57 |             self.assertTrue(current_user.id == 1)
 58 |             self.assertFalse(current_user.id == 20)
 59 | 
 60 |     def test_check_password(self):
 61 |         """ Ensure given password is correct after unhashing """
 62 |         user = User.query.filter_by(username='eschoppik').first()
 63 |         self.assertTrue(bcrypt.check_password_hash(user.password, 'secret'))
 64 |         self.assertFalse(bcrypt.check_password_hash(user.password, 'notsecret'))
 65 | 
 66 |     def test_login_page_loads(self):
 67 |         """Ensure that the login page loads correctly"""
 68 |         response = self.client.get('/users/login')
 69 |         self.assertIn(b'Login', response.data)
 70 | 
 71 |     def test_correct_login(self):
 72 |         """User should be authenticated upon successful login and stored in current user"""
 73 |         with self.client:
 74 |             response = self.client.post(
 75 |                 '/users/login',
 76 |                 data=dict(username="eschoppik", password="secret"),
 77 |                 follow_redirects=True
 78 |             )
 79 |             self.assertIn(b'You are now logged in!', response.data)
 80 | 
 81 | 
 82 |     def test_current_user(self):
 83 |         """A current_user variable is created on g when a user is logged in"""
 84 |         with self.client:
 85 |             self._login_user('eschoppik','secret', True)
 86 |             self.assertEqual(current_user.username, "eschoppik")
 87 | 
 88 |     def test_incorrect_login(self):
 89 |         """The correct flash message is sent when incorrect info is posted"""
 90 |         response = self.client.post(
 91 |             '/users/login',
 92 |             data=dict(username="dsadsa", password="dsadsadsa"),
 93 |             follow_redirects=True
 94 |         )
 95 |         self.assertIn(b"Invalid Credentials", response.data)
 96 | 
 97 |     def test_logout(self):
 98 |         """Make sure log out actually logs out a user"""
 99 |         with self.client:
100 |             self.client.post(
101 |                 '/users/login',
102 |                 data=dict(username="eschoppik", password="secret"),
103 |                 follow_redirects=True
104 |             )
105 |             response = self.client.get('/users/logout', follow_redirects=True)
106 |             self.assertIn(b'Logged Out!', response.data)
107 | 
108 |     def test_logout_route_requires_login(self):
109 |         """Make sure that you can not log out without being logged in"""
110 |         response = self.client.get('/users/logout', follow_redirects=True)
111 |         self.assertIn(b'Please log in to access this page.', response.data)
112 | 
113 |     def testEditPassword(self):
114 |         """Logged In User Editing Password"""
115 |         self._login_user('eschoppik','secret')
116 |         response = self.client.post('/users/1?_method=PATCH',
117 |             data=dict(first_name='a', last_name='b',
118 |             username='bob', password='secret'), follow_redirects=True)
119 |         user = User.query.filter_by(username='bob').first()
120 |         self.assertEqual(response.status_code, 200)
121 |         self.assertEqual(bcrypt.check_password_hash(user.password, 'secret'),True)
122 | 
123 |     def test_add_messages(self):
124 |         """Ensure user can add a message"""
125 |         with self.client:
126 |             self._login_user('eschoppik','secret', follow_redirects=True)
127 |             response = self.client.post('/users/1/messages/', data=dict(content='Hello World',user_id=current_user.id), follow_redirects=True)
128 |             self.assertIn(b'Message Created!', response.data)
129 |             message = Message.query.filter_by(content="Hello World").first()
130 |             self.assertEqual(message.user.first_name, "Elie")
131 |             self.assertEqual(message.content,"Hello World")
132 | 
133 |     def test_edit_messages(self):
134 |         """Ensure user can edit a message"""
135 |         with self.client:
136 |             self._login_user('eschoppik','secret')
137 |             self.client.post('/users/1/messages/', data=dict(content='Hello World',user_id=current_user.id), follow_redirects=True)
138 |             response = self.client.post('/users/1/messages/1?_method=PATCH' , data= dict(
139 |                 content="Hello Everyone", user_id=current_user.id
140 |             ), follow_redirects=True)
141 |             self.assertIn(b'Message Updated!', response.data)
142 |             message = Message.query.filter_by(content="Hello Everyone").first()
143 |             self.assertTrue(message.content == "Hello Everyone")
144 |             self.assertTrue(message.user_id == current_user.id)
145 | 
146 |     def test_delete_message(self):
147 |         """Ensure user can delete a message"""
148 |         with self.client:
149 |             self._login_user('eschoppik','secret')
150 |             self.client.post('/users/1/messages/', data=dict(content='Hello World',user_id=current_user.id), follow_redirects=True)
151 |             response = self.client.post('/users/1/messages/1?_method=DELETE', follow_redirects=True)
152 |             self.assertIn(b'Message Deleted!', response.data)
153 |             message = Message.query.filter_by(content="Hello World").first()
154 |             self.assertFalse(message)
155 | 
156 |     def test_cannot_modify_another_users_message(self):
157 |         """Ensure user can't edit another user's messages"""
158 |         with self.client:
159 |             self._login_user('eschoppik','secret')
160 |             self.client.post('/users/1/messages', data=dict(content='Hello World',user_id=current_user.id), follow_redirects=True)
161 |             user2 = User("Another", "User", "secret", "secret")
162 |             db.session.add(user2)
163 |             db.session.commit()
164 |             self.client.get('/users/logout', follow_redirects=True)
165 |             self._login_user('secret','secret')
166 |             response = self.client.post('/users/1/messages/1?_method=PATCH' , data= dict(
167 |                 text="Here are updated comments.", user_id=current_user.id
168 |             ), follow_redirects=True)
169 |             self.assertIn(b'Not Authorized', response.data)
170 | 
171 |     def test_cannot_delete_another_users_message(self):
172 |         """Ensure user can't delete another user's messages"""
173 |         with self.client:
174 |             self._login_user('eschoppik','secret')
175 |             self.client.post('/users/1/messages', data=dict(content='Hello World',user_id=current_user.id), follow_redirects=True)
176 |             user2 = User("Another", "User", "secret", "secret")
177 |             db.session.add(user2)
178 |             db.session.commit()
179 |             self.client.get('/users/logout', follow_redirects=True)
180 |             self._login_user('secret','secret')
181 |             response = self.client.post('/users/1/messages/1?_method=DELETE', follow_redirects=True)
182 |             self.assertIn(b'Not Authorized', response.data)
183 | 
184 | if __name__ == '__main__':
185 |     unittest.main()
186 | 


--------------------------------------------------------------------------------
/Unit-02/05-oauth/readme.md:
--------------------------------------------------------------------------------
 1 | # OAuth
 2 | 
 3 | 1. Before you add any kind of authentication, first answer the following questions:
 4 | 
 5 | - What is OAuth? 
 6 | - Why is there an OAuth 1 and OAuth 2?
 7 | - What is a client ID?
 8 | - What is a client secret?
 9 | - What is a redirect URL?
10 | - What is an authorization code or grant?
11 | - What is an access token?
12 | - What is a refresh token?
13 | - Diagram / List the steps of an OAuth flow
14 | 
15 | 2. Add OAuth to your users and messages app! Allow users to log in with their email and password as well as log in through Twitter! 
16 | 
17 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Python Exercises
 2 | 
 3 | ### Unit 1 - Flask Fundamentals + SQL
 4 | 
 5 | - [01 Introduction To Flask](./Unit-01/01-flask-intro/readme.md)
 6 | - [02 Routing with Flask](./Unit-01/02-flask-routing/readme.md)
 7 | - [03 Templating with Jinja2](./Unit-01/03-templating/readme.md)
 8 | - [04 CRUD with Flask](./Unit-01/04-flask-crud/readme.md)
 9 | - [05 SQL With Flask and Postgres](./Unit-01/05-sql-flask/readme.md)
10 | - [06 SQL Alchemy, Part I](./Unit-01/06-sql-alchemy-1/readme.md)
11 | - [07 SQL Alchemy, Part II](./Unit-01/07-sql-alchemy-2/readme.md)
12 | - [08 Testing With Flask](./Unit-01/08-testing/readme.md)
13 | - [09 Server Side Validation with WTForms](./Unit-01/09-forms/readme.md)
14 | 
15 | ### Unit 2 - Intermediate Flask
16 | 
17 | - [01 Structuring Larger Flask Applications](./Unit-02/01-blueprints/readme.md)
18 | - [02 Many to Many](./Unit-02/02-many-to-many/readme.md)
19 | - [03 Hashing and Sessions](./Unit-02/03-hashing-sessions/readme.md)
20 | - [04 Authentication with Flask Login](./Unit-02/04-flask-login/readme.md)
21 | - [05 OAuth with Flask](./Unit-02/05-oauth/readme.md)
22 | 


--------------------------------------------------------------------------------