def setUp(self): """Do at the beginning of every test""" # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables from model db.create_all() # Import different types of data from seed file seed.load_users() seed.load_groups() seed.load_usergroups() seed.load_patterns() seed.load_invites() # Reset auto incrementing primary keys to start after seed data seed.set_val_user_id() seed.set_val_group_id() seed.set_val_usergroup_id() seed.set_val_pattern_id() seed.set_val_invite_id() with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1 c.set_cookie('localhost', 'MYCOOKIE', 'cookie_value')
def setUp(self): """Setup to do before every test.""" # Get the Flask test client self.client = app.test_client() app.jinja_env.undefined = StrictUndefined app.jinja_env.filters['prettify_preference'] = prettify_preference # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, db_uri="postgresql:///testdb") # start with empty db db.drop_all() # Create tables and add sample data db.create_all() # create db records for yarns, users, baskets, basket_yarns, # projects, and patterns create_example_data() # create db records for preferences and user_preferences load_preferences("test_data/preference_data.txt") load_user_preferences("test_data/user_preference_data.txt") load_group_events("test_data/group-events.csv")
def test_login(self): """Checks that a user is in session after login with correct credentials.""" sys.stdout.write('Testing login handler...') with app.test_client() as c: self.login(c) assert User.query.filter(User.username=='janet').one().id == 1
def setUp(cls): """Do once before all tests in this class""" # Get the Flask test client cls.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables from model db.create_all() # Import different types of data from seed file seed.load_users() seed.load_groups() seed.load_usergroups() seed.load_patterns() seed.load_invites() seed.set_val_user_id() seed.set_val_group_id() seed.set_val_usergroup_id() seed.set_val_pattern_id() seed.set_val_invite_id() with cls.client as c: with c.session_transaction() as sess: sess['user_id'] = 1 c.set_cookie('localhost', 'MYCOOKIE', 'cookie_value')
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() # Connect to test database connect_to_db(app) # Create tables and add sample data db.create_all() _example_data() app.config['TESTING'] = True app.config['SECRET_KEY'] = 'Aisling' self.client = app.test_client()
def setUp(self): """Do before every test.""" # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, "postgresql:///testdb") db.create_all() # Make mocks def _mock_get_yelp_search_results(term, location, category_filter, limit): """Mocks search results of Yelp API call for one restaurant.""" search_results = {"businesses": [{"rating": 4.5, "rating_img_url": "https://s3-media2.fl.yelpcdn.com/assets/2/www/img/99493c12711e/ico/stars/v1/stars_4_half.png", "review_count": 547, "name": "Saru Sushi Bar", "rating_img_url_small": "https://s3-media2.fl.yelpcdn.com/assets/2/www/img/a5221e66bc70/ico/stars/v1/stars_small_4_half.png", "url": "http://www.yelp.com/biz/saru-sushi-bar-san-francisco?utm_campaign=yelp_api&utm_medium=api_v2_search&utm_source=6XuCRI2pZ5pIvcWc9SI3Yg", "image_url": "https://s3-media2.fl.yelpcdn.com/bphoto/5-ugy01zjSvudVsfdhmCsA/ms.jpg", "display_phone": "+1-415-400-4510", "id": "saru-sushi-bar-san-francisco", "location": {"city": "San Francisco", "postal_code": "94114", "country_code": "US", "address": ["3856 24th St"], "coordinate": {"latitude": 37.751706, "longitude": -122.4288283}, "state_code": "CA"}}]} return search_results def _mock_is_open_now_true(keyword, location): """Mocks Google Places API call to return True for current open status.""" return True self._old_is_open_now = process_results.is_open_now process_results.is_open_now = _mock_is_open_now_true self.old_get_yelp_search_results = server.yelp.search_query server.yelp.search_query = _mock_get_yelp_search_results
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() # Mock session # Connect to temporary database connect_to_db(app, "sqlite:///") # Create tables and add sample data db.create_all() sample_data() def _mock_grab_image_dimensions(filename): return (920, 764) self._old_grab_image_dimensions = server.grab_image_dimensions server.grab_image_dimensions = _mock_grab_image_dimensions def _mock_generate_thumb(filename, crop_thumb): return None self._old_generate_thumb = server.generate_thumb server.generate_thumb = _mock_generate_thumb
def test_homepage(self): self.client = app.test_client() result = self.client.get("/") print dir(result) #### status_code, content_type=HTML, data self.asserIn("here", result.data) self.assertEqual(result.status_code,200)
def setUp(self): # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables from model db.create_all() # Import different types of data from seed file seed.load_users() seed.load_groups() seed.load_usergroups() seed.load_patterns() seed.load_invites() # Reset auto incrementing primary keys to start after seed data seed.set_val_user_id() seed.set_val_group_id() seed.set_val_usergroup_id() seed.set_val_pattern_id() seed.set_val_invite_id()
def setUp(self): app.config['TESTING'] = True app.config['CSRF_ENABLED'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(app.root_path, 'test.db') self.app = app.test_client() server.clean_db() db.create_all()
def setUp(self): self.client = app.test_client() app.config['TESTING'] = True app.config['SECRET_KEY'] = 'key' # Connect to test database connect_to_db(app, "postgresql:///testdb")
def setUp(self): """Set up a blank temp database before each test""" app.config['TESTING'] = True app.config['CSRF_ENABLED'] = False app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, TEST_DB) self.app = app.test_client() db.create_all()
def setUp(self): """Setup to do before every test.""" # Get the Flask test client self.client = app.test_client() # secret key to allow sessions to be used app.config['SECRET_KEY'] = 'sekrit!' # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, db_uri="postgresql:///testdb") # Create tables and add sample data db.create_all() # create db records for yarns, users, baskets, basket_yarns, # projects, and patterns create_example_data() # create db records for preferences and user_preferences load_preferences("test_data/preference_data.txt") load_user_preferences("test_data/user_preference_data.txt") with self.client as c: with c.session_transaction() as session: session['username'] = '******'
def test_login(self): """Checks that a user is in session after login with correct credentials.""" sys.stdout.write('Testing login handler...') with app.test_client() as c: self.login(c) assert flask.session['email'] == "*****@*****.**"
def setUp(self): print "\n\n\n\n (2) DOING A SEARCH TEST \n\n\n\n" self.client = app.test_client() app.config['TESTING'] = True postgrespassword = os.environ['POSTGRES_PASSWORD'] db_uri = 'postgresql://' + postgrespassword + '/test' connect_to_db(app, db_uri) db.create_all() load_regions() load_users() load_bestuses() load_categories() load_brands() load_products() load_tents() load_filltypes() load_gendertypes() load_sleepingbags() load_padtypes() load_sleepingpads() load_ratings() load_histories() load_test_postalcodes()
def test_Classifier_data(self): print 'Test for proper csv saving' tester = app.test_client(self) fingers_data = [ [0,1,2,3,4], [1,2,3,4,5], [2,3,4,5,6], [3,4,5,6,7] ] response = tester.post('/data', data=dict( exercise = 0, fingers = fingers_data, time = 666, success = 0, pain = 1 ), follow_redirects=True); f = open('classificationData.csv' ,'r') reader = csv.reader(f,delimiter=',', quotechar='|') header = reader.next() self.assertEqual(header[0], 'finger1') firstRow = reader.next() self.assertEqual(int(firstRow[0]), 0) self.assertEqual(int(firstRow[5]), 1) os.remove('classificationData.csv') assert json.loads(response.data)
def setUp(self): self.client = app.test_client() app.config["TESTING"] = True app.config["SECRET_KEY"] = "key" connect_to_db(app, db_uri="postgresql:///testdb") db.create_all()
def setUp(self): self.client = app.test_client() app.config["TESTING"] = True app.config["SECRET_KEY"] = "key" with self.client.session_transaction() as sess: sess["user_id"] = 1 sess["username"] = "******"
def test_get_anno(self): # sends HTTP GET request to the application # on the specified path tester = app.test_client(self) result = tester.get('/annotations/api/v1.0/annos', content_type='application/ld+json') # assert the status code of the response self.assertEqual(result.status_code, 200)
def setUp(self): self.client = app.test_client() app.config['TESTING'] = True connect_to_db(app, "postgresql:///testdb") db.create_all() example_data_high_scores()
def setUp(self): """Stuff to do before every test.""" self.client = app.test_client() app.config['TESTING'] = True self.test_YP = YumPossibilities(37.773972, -122.431297, 'brunch') server.call_yelp = self._mock_call_yelp
def setUp(self): """Set up app, session key, and fake client.""" app.config['TESTING'] = True self.client = app.test_client() connect_to_db(app, 'postgresql:///testdb') db.create_all()
def setUp(self): self.client = app.test_client() app.config['TESTING'] = True def _mock_get_img_url(soup): return "http://cdn3.minimalistbaker.com/wp-content/uploads/2016/06/Cauliflower-Rice-Stuffed-Pepper-SQUARE.jpg" webscrape_details.get_img_url = _mock_get_img_url
def test_get_existing_user(): client = app.test_client() response = client.get("/api/v1/users/3") response_contents = json.loads(next(response.response).decode("utf-8")) assert response.status_code == 200 assert response.headers["Content-Type"] == "application/json" assert response_contents["_id"] == "3" assert response_contents["name"] == "John Doe"
def setUp(self): app.config.from_object('config.TestingConfig') self.client = app.test_client() with app.app_context(): init_app() user_datastore.create_user(email='test', password=encrypt_password('test')) db.session.commit()
def setUp(self): """before every test""" self.client = app.test_client() app.config['TESTING'] = True connect_to_db(app, 'postgresql:///testsubreddits') db.create_all() make_test_data()
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True
def setUp(self): self.client = app.test_client() app.config['TESTING'] = True app.config['SECRET_KEY'] = 'BalloonicornSmash' # Connect to the database connect_to_db(app, db_uri=travis_db_uri) # Reset the world so we start with clean data seed_force(app)
def setUp(self): self.app = app.test_client() app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' app.config['TESTING'] = True app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db.app = app db.init_app(app) db.create_all()
def setUp(self): """Stuff to do before every test.""" self.client = app.test_client() app.config['TESTING'] = True app.config['SECRET_KEY'] = "JMD" connect_to_db(app, "postgresql:///testdb") db.create_all() example_data()
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables and add sample data db.create_all() load_users() with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1
def setUp(self): with app.test_client() as c: self.uuids1 = [] self.uuids2 = [] c.set_cookie("localhost", "access_token_cookie", TOKEN_USER) for i in range(0, 2): response = c.post( "/organizations", headers={"x-csrf-token": TOKEN_USER_CSRF}, json={"name": get_random_name()}, ) self.uuids1.append(response.json["uuid"]) c.set_cookie("localhost", "access_token_cookie", TOKEN_USER2) response = c.post( "/organizations", headers={"x-csrf-token": TOKEN_USER2_CSRF}, json={"name": get_random_name()}, ) self.uuids2.append(response.json["uuid"])
def setUp(self): """Before every test""" app.config['TESTING'] = True self.client = app.test_client() # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables and add sample data db.create_all() example_data() with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1 # Make mock def _mock_recipe_search(search_name, recipe_id): """ Mocks info returned from Spoonacular API. """ example_search = fake_api_json.recipe_search('pasta', 1) return example_search def _mock_summary_info(recipe_id): """ Mocks info returned from Spoonacular API. """ example_summary = fake_api_json.summary_info('548180') return example_summary def _mock_recipe_info(recipe_id): """ Mocks info returned from Spoonacular API. """ example_info = fake_api_json.recipe_info('548180') return example_info # Attaches mocks calls to app's real calls api_calls.recipe_search = _mock_recipe_search api_calls.summary_info = _mock_summary_info api_calls.recipe_info = _mock_recipe_info
def test_list_fields(self, mock_get_uri): with app.test_client() as c: c.set_cookie("localhost", "access_token_cookie", TOKEN_USER) response = c.get( "/printers?fields=webcam,status,job", headers={"x-csrf-token": TOKEN_USER_CSRF}, ) self.assertEqual(response.status_code, 200) # coming from db fixtures self.assertTrue("items" in response.json) self.assertTrue(len(response.json["items"]) >= 2) self.assertTrue("client" in response.json["items"][0]) self.assertTrue("webcam" in response.json["items"][0]) self.assertTrue("status" in response.json["items"][0]) self.assertTrue("job" in response.json["items"][0]) self.assertTrue("client" in response.json["items"][1]) self.assertTrue("webcam" in response.json["items"][1]) self.assertTrue("status" in response.json["items"][1]) self.assertTrue("job" in response.json["items"][1])
def test_delete(self, mock_get_uri, mock_avahi): with app.test_client() as c: c.set_cookie("localhost", "access_token_cookie", TOKEN_ADMIN) ip = "192.168.%s" % ".".join( [str(random.randint(0, 255)) for _ in range(2)]) response = c.post( "/printers", headers={"x-csrf-token": TOKEN_ADMIN_CSRF}, json={ "ip": ip, "name": "random-test-printer-name" }, ) self.assertEqual(response.status_code, 201) response = c.delete( "/printers/%s" % response.json["uuid"], headers={"x-csrf-token": TOKEN_ADMIN_CSRF}, ) self.assertEqual(response.status_code, 204)
def test_good_booking(self): # Create a test client using the Flask application configured for testing with app.test_client() as test_client: club_name = 'Simply Lift TEST' club_balance_before = [ int(club['points']) for club in clubs if club['name'] == club_name ][0] response = test_client.post('/purchasePlaces', data=dict( competition='TEST Competitiion', club=club_name, places=2), follow_redirects=True) assert response.status_code == 200 # check if the club current balance have changed assert str(club_balance_before - int(request.form['places']) * 3) in str(response.data) assert b"Great-booking complete!" in response.data
def setUp(self): """Setting up tests for pages where user is logged in""" self.client = app.test_client() app.config['TESTING'] = True # shows debugging output connect_to_db(app, "postgresql:///testdb" ) # work on this postg understanding and db test app.config['SECRET_KEY'] = 'key' with self.client as c: with c.session_transaction() as sess: sess['user_name'] = 'Brian' sess['user_id'] = 1 sess['hometown'] = 2 sess['hometown_name'] = 'Selby' #create tables and ad sample data db.create_all() example_data()
def setUp(self): """Stuff to do before every test.""" app.config['TESTING'] = True app.config['SECRET_KEY'] = 'ABC' self.client = app.test_client() with self.client as c: with c.session_transaction() as sess: sess['current_user'] = "******" # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables and add sample data db.drop_all() db.create_all() example_data()
def setUp(self): """Stuff to do before every test.""" app.config['TESTING'] = True app.config['SECRET_KEY'] = 'key' self.client = app.test_client() with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1 connect_to_db(app, "postgresql:///testdb") # Create tables and add sample data db.create_all() # import pdb # pdb.set_trace() example_data()
def test_list(self): with app.test_client() as c: c.set_cookie("localhost", "access_token_cookie", TOKEN_USER) response = c.get("/gcodes", headers={"x-csrf-token": TOKEN_USER_CSRF}) self.assertEqual(response.status_code, 200) self.assertTrue("items" in response.json) if len(response.json["items"]) < 200: self.assertTrue("next" not in response.json) self.assertTrue(len(response.json["items"]) >= 2) self.assertTrue("id" in response.json["items"][0]) self.assertTrue("user_uuid" in response.json["items"][0]) self.assertTrue("username" in response.json["items"][0]) self.assertTrue("path" in response.json["items"][0]) self.assertTrue("display" in response.json["items"][0]) self.assertTrue("absolute_path" in response.json["items"][0]) self.assertTrue("uploaded" in response.json["items"][0]) self.assertTrue("size" in response.json["items"][0]) self.assertTrue("data" in response.json["items"][0]) self.assertTrue(response.json["items"][0]["username"] is not None)
def setUp(self): """Necessary before every test. Configures the app, creates client, connects to test database, creates the tables, and seeds the test database.""" # Get the Flask test client app.config['TESTING'] = True app.config['SECRET_KEY'] = 'ABC' self.client = app.test_client() # Connect to test database connect_to_db(app, uri='postgres:///testdb') # Create tables and add sample data example_data() with self.client as c: with c.session_transaction() as sess: sess['user'] = '******'
def setUp(self): self.client = app.test_client() app.config['TESTING'] = True connect_to_db(app, "postgresql:///testdb") db.create_all() example_data() with self.client as c: with c.session_transaction() as sess: sess['username'] = '******' self.client.post('/login', data={ 'username': '******', 'password': '******' }, follow_redirects=True)
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1 # Connect to test database connect_to_db(app, "testdb") #create testdb based on model.py # # Create tables and add sample data db.create_all() example_data()
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() #Shows Flask errors that happen during tests app.config['TESTING'] = True #To test sessions we need to set Secret key app.config['SECRET_KEY'] = 'key' # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables and add sample data db.create_all() users() reviews()
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() app.config['TESTING'] = True app.config['SECRET_KEY'] = 'key' # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables and add sample data db.create_all() populate_example_data() with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1 sess['name'] = "First1"
def setUp(self): """Setup for database function testing.""" # Get the Flask test client. self.client = app.test_client() app.config["TESTING"] = True app.config["SECRET_KEY"] = "key" app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False with self.client as c: with c.session_transaction() as sess: sess["dietitian_id"] = 1 # Connect to the test database. connect_to_db(app, db_uri="postgresql:///testnourish") # Create the tables and add the sample data. db.create_all() load_test_data()
def test_send_email_with_reset_link(self, mock_send_mail): with app.test_client() as c: email = get_random_email() c.post("/users/me", json={"email": email}) user = users.get_by_email(email) users.update_user(uuid=user["uuid"], activated=datetime.now()) local_users.add_local_user(user_uuid=user["uuid"], pwd_hash="aaa", force_pwd_change=False) response = c.post("/users/me/request-password-reset", json={"email": email}) self.assertEqual(response.status_code, 202) self.assertEqual(mock_send_mail.call_count, 2) args = mock_send_mail.call_args_list self.assertEqual(args[1][0][0][0], email) self.assertEqual(args[1][0][1], "PASSWORD_RESET_LINK") self.assertTrue(args[1][0][2]["pwd_reset_key"] is not None) self.assertTrue(args[1][0][2]["pwd_reset_key_expires"] is not None) self.assertEqual(args[1][0][2]["email"], email)
def setUp(self): """Prepare for each test before execution.""" self.app = app.test_client() app.config['TESTING'] = True app.config['SECRET_KEY'] = 'key' connect_to_db(app, 'postgresql:///testdb') db.create_all() load_users() load_activities() load_sessions() load_records() with self.app as c: with c.session_transaction() as sess: sess['user_id'] = 2 sess['sess_id'] = 40
def test_delete(self): gcode_uuid = gcodes.add_gcode( uuid=guid.uuid4(), path="delete-ab/c", filename="delete-gcode-specific-file1", display="file-display", absolute_path="/ab/a/b/c", size=123, user_uuid=UUID_USER, organization_uuid=UUID_ORG, ) printjobs.add_printjob( uuid=guid.uuid4(), gcode_uuid=gcode_uuid, gcode_data={"uuid": gcode_uuid}, printer_uuid="20e91c14-c3e4-4fe9-a066-e69d53324a20", printer_data={"host": "172.16.236.11:8080"}, organization_uuid=UUID_ORG, ) printjobs.add_printjob( uuid=guid.uuid4(), gcode_uuid=gcode_uuid, gcode_data={"uuid": gcode_uuid}, printer_uuid="20e91c14-c3e4-4fe9-a066-e69d53324a20", printer_data={"host": "172.16.236.11:8080"}, organization_uuid=UUID_ORG, ) with app.test_client() as c: c.set_cookie("localhost", "access_token_cookie", TOKEN_USER) response = c.delete( "/organizations/%s/gcodes/%s" % (UUID_ORG, gcode_uuid), headers={"x-csrf-token": TOKEN_USER_CSRF}, ) self.assertEqual(response.status_code, 204) self.assertEqual(gcodes.get_gcode(gcode_uuid), None) pjs = [ pj for pj in printjobs.get_printjobs(UUID_ORG) if pj["gcode_data"]["uuid"] == gcode_uuid ] self.assertEqual(len(pjs), 2) for pj in pjs: self.assertFalse(pj["gcode_data"]["available"])
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True app.config['SECRET_KEY'] = 'key' # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables and seed with data db.create_all() load_location('locations_fortest.txt') load_person('user_examples.txt') load_saved_record('records_fortest.txt') def _mock_get_locations_dict(loc_lst): mock_dict = {} mock_forecast = open('mock_forecast_response.txt', 'r').read() mock_forecast = json.loads(mock_forecast) for loc in loc_lst: mock_dict[loc] = mock_forecast return mock_dict def _mock_get_location_geojson(loc_lst): geojson_str = """{ "features": [ { "geometry": { "coordinates": [ -100.00, 100.00 ], "type": "Point" }, "properties": { "id": 1, "name": "StarsEverywhere", "light": 1 }, "type": "Feature" }], "type" : "FeatureCollection"}""" return geojson_str import server server.get_locations_dict = _mock_get_locations_dict server.get_location_geojson = _mock_get_location_geojson
def test_delete(self, mock_send_mail): with app.test_client() as c: c.set_cookie("localhost", "access_token_cookie", TOKEN_ADMIN) email = get_random_email() response = c.post( "/organizations/%s/users" % UUID_ORG, headers={"x-csrf-token": TOKEN_ADMIN_CSRF}, json={ "role": "user", "email": email, }, ) self.assertEqual(response.status_code, 201) uuid = response.json["uuid"] user = users.get_by_email(email) api_tokens.add_token( user_uuid=uuid, jti=guid.uuid4(), organization_uuid=UUID_ORG, name="jti", ) self.assertTrue(user["uuid"], uuid) response = c.delete( "/organizations/%s/users/%s" % (UUID_ORG, uuid), headers={"x-csrf-token": TOKEN_ADMIN_CSRF}, ) self.assertEqual(response.status_code, 204) orgrole = organization_roles.get_organization_role( UUID_ORG, user["uuid"]) tokens = api_tokens.get_tokens_for_user_uuid(user["uuid"], org_uuid=UUID_ORG) self.assertTrue(user is not None) self.assertTrue(orgrole is None) for t in tokens: self.assertTrue(t["revoked"]) self.assertTrue(t["organization_uuid"] == UUID_ORG) args = mock_send_mail.call_args_list self.assertEqual(args[1][0][0][0], email) self.assertEqual(args[1][0][1], "ORGANIZATION_REMOVAL") self.assertTrue(args[1][0][2]["organization_name"] is not None) self.assertTrue(args[1][0][2]["organization_uuid"] is not None) self.assertEqual(args[1][0][2]["email"], email)
def test_reset_password(self, mock_send_mail): with app.test_client() as c: response = c.post( "/users/me/reset-password", json={ "email": self.email, "pwd_reset_key": self.pwd_reset_key, "password": "******", "password_confirmation": "aaa", }, ) self.assertEqual(response.status_code, 204) local_user = local_users.get_local_user(self.user_uuid) self.assertTrue(local_user["pwd_reset_key_hash"] is None) self.assertTrue(local_user["pwd_reset_key_expires"] is None) self.assertEqual(mock_send_mail.call_count, 1) args = mock_send_mail.call_args_list self.assertEqual(args[0][0][0][0], self.email) self.assertEqual(args[0][0][1], "PASSWORD_RESET_CONFIRMATION") self.assertEqual(args[0][0][2]["email"], self.email)
def test_filter_next(self): with app.test_client() as c: c.set_cookie("localhost", "access_token_cookie", TOKEN_USER) response = c.get( "/organizations/%s/printjobs?filter=printer_uuid:e24a9711-aabc-48f0-b790-eac056c43f07&limit=10&order_by=-uuid" % UUID_ORG, headers={"x-csrf-token": TOKEN_USER_CSRF}, ) self.assertEqual(response.status_code, 200) self.assertTrue("items" in response.json) self.assertTrue("next" in response.json) self.assertTrue(len(response.json["items"]) == 10) response2 = c.get( response.json["next"], headers={"x-csrf-token": TOKEN_USER_CSRF}, ) self.assertEqual(response2.status_code, 200) self.assertTrue("items" in response2.json) self.assertTrue(response.json["items"][0]["uuid"] > response2.json["items"][0]["uuid"])
def setUp(self): """ Things to do before every test.""" # Get the Flask test client self.client = app.test_client() app.config['TESTING'] = True # Connect to test database connect_to_db(app, "postgresql:///testfood") # Create tables and add sample data db.create_all() example_data() # Create a session app.config['SECRET_KEY'] = os.environ["testing_secret_key"] with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1
def setUp(self): """Done before every test.""" # Get the Flask test client self.client = app.test_client() app.config['TESTING'] = True app.config['SECRET_KEY'] = 'testingSecrets' with self.client as c: with c.session_transaction() as sess: # Log in as 'Potato' user sess['user'] = 2 # Connect to test database connect_to_db(app, "postgresql:///testdb") UPLOAD_FOLDER = 'static/Testing/testfiles' app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER db.create_all() set_acceptable_media_types() create_data()
def test_update_user(self): with app.test_client() as c: c.set_cookie("localhost", "access_token_cookie", TOKEN_ADMIN) response = c.patch( "/users/%s" % self.uuid, headers={"x-csrf-token": TOKEN_ADMIN_CSRF}, json={ "role": "admin", "suspended": True }, ) self.assertEqual(response.status_code, 200) self.assertTrue("role" in response.json) self.assertTrue("suspended" in response.json) self.assertEqual(response.json["role"], "admin") self.assertEqual(response.json["suspended"], True) user = users.get_by_uuid(self.uuid) self.assertTrue(user is not None) self.assertEqual(user["role"], "admin") self.assertEqual(user["suspended"], True)
def setUp(self): ''' runs before each test ''' # test_client simulates that the server is running # app defined inside server app.config['TESTING'] = True self.client = app.test_client() connect_to_db(app, "postgresql:///testdb") db.create_all() example_data() # adds a user to the session to carry out routes while logged in # user = User.query.filter_by(username='******').first() with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 2 sess['game_id'] = 4 sess['difficulty_level'] = "3" sess['name'] = 'teddy'
def setUp(self): """Set up test database and mock api result.""" self.client = app.test_client() app.config['TESTING'] = True connect_to_db(app, "postgresql:///testdb") db.create_all() example_data() # Make mock def _mock_find_route_coordinates(origin, destination): return [(37.8067567, -122.2961741), (37.8070326, -122.2974171), (37.8167166, -122.2896513), (37.8276755, -122.2890558), (37.8279634, -122.2893052), (37.8280475, -122.288937), (37.8287455, -122.2891528), (37.8290338, -122.2886093), (37.8291819, -122.2886597)] find_route_coordinates = _mock_find_route_coordinates
def setUp(self): """Method called before each test.""" # Flask's test client is instantiated. self.client = app.test_client() # Flask's TESTING configuration variable is set so that any Flask error # will be printed in the same console as the tests. This makes it # easy to debug any errors that occur during tests. app.config['TESTING'] = True app.config['DEBUG'] = False # Required configuration for apps that use sessions. app.config['SECRET_KEY'] = 'key' # Assigns the test client a user_if of 1. # Useful for testing the parts of my app that require login. with self.client as c: with c.session_transaction() as sess: sess['user_id'] = 1
def setUp(self): """Stuff to do before every test.""" # Get the Flask test client self.client = app.test_client() # Show Flask errors that happen during tests app.config['TESTING'] = True # Connect to test database connect_to_db(app, "postgresql:///testdb") # Create tables and add sample data db.create_all() example_data_users() # initiate a session with self.client.session_transaction() as session: session['user'] = '******' self.client.set_cookie('localhost', 'MYCOOKIE', 'cookie_value')