def test_create_zone( self, client, common_data_mock, zone_data, admin_apikey, created_zone_data ): with patch('app.lib.helper.requests.request') as mock_post, \ patch('app.blueprints.api.Domain') as mock_domain: mock_post.return_value.status_code = 201 mock_post.return_value.content = json.dumps(created_zone_data) mock_post.return_value.headers = {} mock_domain.return_value.update.return_value = True res = client.post( "/api/v1/servers/localhost/zones", headers=admin_apikey, data=json.dumps(zone_data), content_type="application/json" ) data = res.get_json(force=True) data['rrsets'] = [] validate_zone(data) assert res.status_code == 201
def test_get_multiple_zones(self, client, initial_data, zone_data, basic_auth_admin_headers): res = client.post("/api/v1/pdnsadmin/zones", headers=basic_auth_admin_headers, data=json.dumps(zone_data), content_type="application/json") data = res.get_json(force=True) data['rrsets'] = [] validate_zone(data) assert res.status_code == 201 res = client.get("/api/v1/pdnsadmin/zones", headers=basic_auth_admin_headers) data = res.get_json(force=True) fake_domain = namedtuple("Domain", data[0].keys())(*data[0].values()) domain_schema = DomainSchema(many=True) json.dumps(domain_schema.dump([fake_domain])) assert res.status_code == 200 zone_url_format = "/api/v1/pdnsadmin/zones/{0}" zone_url = zone_url_format.format(zone_data['name'].rstrip(".")) res = client.delete(zone_url, headers=basic_auth_admin_headers) assert res.status_code == 204
def test_delete_zone( self, client, initial_apikey_data, zone_data, admin_apikey_integration ): res = client.post( "/api/v1/servers/localhost/zones", headers=admin_apikey_integration, data=json.dumps(zone_data), content_type="application/json" ) data = res.get_json(force=True) data['rrsets'] = [] validate_zone(data) assert res.status_code == 201 zone_url_format = "/api/v1/servers/localhost/zones/{0}" zone_url = zone_url_format.format(zone_data['name'].rstrip(".")) res = client.delete( zone_url, headers=admin_apikey_integration ) assert res.status_code == 204
def test_get_should_return_operator(client): client.post( "/operators", json=operator_not_written, ) res = client.get("/operators/3") assert res.status_code == 200 assert res.json["firstname"] == operator_not_written["firstname"] assert res.json["lastname"] == operator_not_written["lastname"] assert res.json["birthdate"] == operator_not_written["birthdate"].strftime( "%Y-%m-%d") assert res.json["fiscalcode"] == operator_not_written["fiscalcode"] assert res.json["email"] == operator_not_written["email"] assert res.json["phonenumber"] == operator_not_written["phonenumber"]
def test_login_should_be_wrong_credentials(client): client.post( "/operators", json=operator_not_written, ) res = client.post( "/operators/login", json={ "email": operator_not_written["email"], "password": "******" }, ) assert res.status_code == 200 assert res.json["message"] == "Wrong credentials"
def test_patch_should_be_successful(client, db): client.post( "/users", json=user1, ) res = client.patch("/users/1", json={ "firstname": "Giovanni", "lastname": "Verdi" }) q = db.session.query(User).filter_by(id=1).first() assert res.status_code == 204 assert q.firstname == "Giovanni" assert q.lastname == "Verdi"
def test_login_should_be_successful(client): client.post( "/operators", json=operator_not_written, ) res = client.post( "/operators/login", json={ "email": operator_not_written["email"], "password": operator_not_written["password"], }, ) assert res.status_code == 200 assert res.json["message"] == "Success"
def test_unknown_session_id_response_body(self, client): response = client.post('/rulesets', json={'session_id': str(ObjectId())}) assert response.get_json() == { 'status': 404, 'field': 'session_id', 'error': 'unknown' }
def test_get_multiple_apikey(self, client, initial_data, apikey_data, zone_data, basic_auth_admin_headers): res = client.post("/api/v1/pdnsadmin/zones", headers=basic_auth_admin_headers, data=json.dumps(zone_data), content_type="application/json") data = res.get_json(force=True) assert res.status_code == 201 res = client.post("/api/v1/pdnsadmin/apikeys", headers=basic_auth_admin_headers, data=json.dumps(apikey_data), content_type="application/json") data = res.get_json(force=True) validate_apikey(data) assert res.status_code == 201 res = client.get("/api/v1/pdnsadmin/apikeys", headers=basic_auth_admin_headers) data = res.get_json(force=True) fake_role = namedtuple( "Role", data[0]['role'].keys())(*data[0]['role'].values()) data[0]['domains'] = [] data[0]['role'] = fake_role fake_apikey = namedtuple("ApiKey", data[0].keys())(*data[0].values()) apikey_schema = ApiKeySchema(many=True) json.dumps(apikey_schema.dump([fake_apikey])) assert res.status_code == 200 apikey_url_format = "/api/v1/pdnsadmin/apikeys/{0}" apikey_url = apikey_url_format.format(fake_apikey.id) res = client.delete(apikey_url, headers=basic_auth_admin_headers) assert res.status_code == 204 zone_url_format = "/api/v1/pdnsadmin/zones/{0}" zone_url = zone_url_format.format(zone_data['name'].rstrip(".")) res = client.delete(zone_url, headers=basic_auth_admin_headers) assert res.status_code == 204
def test_login(client: client): # login with no credentials response = client.post("/api/auth/login", json={}) assert_json_status(response, BadRequest.code) # login with incorrect credentials response = client.post("/api/auth/login", json=CREDENTIALS_BAD) assert_json_status(response, Unauthorized.code) # successful login response = client.post("/api/auth/login", json=CREDENTIALS_GOOD) assert_json_status(response, OK_STATUS) store_check_auth(response, credentials=CREDENTIALS_GOOD) # successful alt login response = client.post("/api/auth/login", json=CREDENTIALS_ALT) assert_json_status(response, OK_STATUS) store_check_auth(response, credentials=CREDENTIALS_ALT)
def test_login_should_be_authority_not_found(client): res = client.post( "/authorities/login", json={ "email": health_authority_not_written["email"], "password": health_authority_not_written["password"], }, ) assert res.status_code == 404 assert res.json["message"] == "Authority not found"
def test_should_mark_one_user_through_phonenumber(client, db): res = client.post( "/authorities/1/mark", json={"identifier": user1["phonenumber"], "duration": 15}, follow_redirects=False, ) q = User.query.filter_by(id=1).first() assert q.marked assert res.status_code == 204
def test_login_should_be_operator_not_found(client): res = client.post( "/operators/login", json={ "email": operator_not_written["email"], "password": operator_not_written["password"], }, ) assert res.status_code == 404 assert res.json["message"] == "Operator not found"
def test_login_should_be_user_not_found(client): res = client.post( "/users/login", json={ "email": "thisdoesnotexist", "password": "******", }, ) assert res.status_code == 404 assert res.json["message"] == "User not found"
def test_create_character(client: client): # create a character with too much stats response = client.post("/api/game/create_character", json={ "name": "good", "description": "good", "strength": 10, "dexterity": 10, "health": 10, "special": "lightning" }, headers=with_auth_headers()) assert_json_status(response, BadRequest.code) # create a character for "GOOD" response = client.post( "/api/game/create_character", json={ "name": "good", "description": "good", "strength": 5, "dexterity": 10, "health": 5, "special": "lightning" }, headers=with_auth_headers(credentials=CREDENTIALS_GOOD)) assert_json_status(response, OK_STATUS) # create a character for "ALT" response = client.post( "/api/game/create_character", json={ "name": "alt", "description": "alt", "strength": 10, "dexterity": 1, "health": 9, "special": "wither" }, headers=with_auth_headers(credentials=CREDENTIALS_ALT)) assert_json_status(response, OK_STATUS)
def create_review(client, message=None, rating=5, redirect=True): if not message: message = "It was a delicious dinner, but initially the service was not so excellent in the speed of serving the meals." return client.post( "/restaurants/1", data=dict( rating=rating, message=message, ), follow_redirects=redirect, )
def test_bad_access_token_user_login(client, app, mocker): # noqa mocker.patch('requests.get', MockResponse(401, {'error': { 'message': 'oops' }})) data = {'timezone': 'US/Pacific', 'access_token': '123'} res = client.post(flask.url_for('auth.login'), data=json.dumps(data), headers={'Content-Type': 'application/json'}) assert res.status_code == 401
def test_decide_challenge(client: client): # accept the challenge as ALT response = client.post( "/api/game/challenge/decide", json={ "id": VARS["challenge_id"], "accept": True, "character": "alt" }, headers=with_auth_headers(credentials=CREDENTIALS_ALT)) assert_json_status(response, OK_STATUS) VARS["game_id"] = response.json["game_id"]
def test_create_challenge(client: client): # send a challenge from GOOD to ALT response = client.post("/api/game/challenge", json={ "defender": CREDENTIALS_ALT["username"], "challenge_config": { "max_turns": 5, "character": "good" } }, headers=with_auth_headers()) assert_json_status(response, OK_STATUS) VARS["challenge_id"] = response.json["challenge_id"]
def test_post_should_be_successful(client, db): res = client.post("/users", json=user_not_written) q = db.session.query(User).filter_by(id=7).first() assert res.status_code == 201 assert q.firstname == user_not_written["firstname"] assert q.lastname == user_not_written["lastname"] assert q.birthdate.strftime( "%Y-%m-%d") == user_not_written["birthdate"].strftime("%Y-%m-%d") assert q.fiscalcode == user_not_written["fiscalcode"] assert q.email == user_not_written["email"] assert q.phonenumber == user_not_written["phonenumber"]
def test_user_should_not_create_review_when_message_is_less_than_30_character( client, db): helpers.create_user(client) helpers.login_user(client) helpers.insert_complete_restaurant(db) res = client.post( "/restaurants/1", data=dict(rating=4, message="It was a"), follow_redirects=True, ) assert res.status_code == 200 assert b"The review should be at least of 30 characters." in res.data
def test_create(client): data = {'firstname': 'Binom', 'lastname': 'Missieu'} response = client.post('/players', data=json.dumps(data), content_type='application/json') player_id = client.database.execute('SELECT (id) FROM players;')[0]['id'] assert response.status_code == 201 assert json.loads(response.data) == { "id": player_id, "firstname": "Binom", "lastname": "Missieu" }
def test_delete_should_be_successful(client, db): res = client.post( "/users", json=user1, ) res = client.delete("/users/1") q = db.session.query(User).filter_by(id=1).first() assert res.status_code == 204 assert q.firstname == "" assert q.lastname == "" assert q.fiscalcode == "" assert q.phonenumber == "" assert not q.birthdate assert q.email == "deleted"
def test_post_should_be_successful(client, db): res = client.post( "/authorities", json=health_authority_not_written, ) q = db.session.query(HealthAuthority).filter_by(id=3).first() assert res.status_code == 201 assert q.name == health_authority_not_written["name"] assert q.email == health_authority_not_written["email"] assert q.phonenumber == health_authority_not_written["phonenumber"] assert q.country == health_authority_not_written["country"] assert q.city == health_authority_not_written["city"] assert q.state == health_authority_not_written["state"] assert q.lat == health_authority_not_written["lat"] assert q.lon == health_authority_not_written["lon"]
def test_delete_zone(self, client, initial_data, zone_data, basic_auth_admin_headers): res = client.post("/api/v1/pdnsadmin/zones", headers=basic_auth_admin_headers, data=json.dumps(zone_data), content_type="application/json") data = res.get_json(force=True) data['rrsets'] = [] validate_zone(data) assert res.status_code == 201 zone_url_format = "/api/v1/pdnsadmin/zones/{0}" zone_url = zone_url_format.format(zone_data['name'].rstrip(".")) res = client.delete(zone_url, headers=basic_auth_admin_headers) assert res.status_code == 204
def test_create_zone(self, client, common_data_mock, zone_data, basic_auth_admin_headers, created_zone_data): with patch('powerdnsadmin.lib.helper.requests.request') as mock_post, \ patch('powerdnsadmin.routes.api.Domain') as mock_domain: mock_post.return_value.status_code = 201 mock_post.return_value.content = json.dumps(created_zone_data) mock_post.return_value.headers = {} mock_domain.return_value.update.return_value = True res = client.post("/api/v1/pdnsadmin/zones", headers=basic_auth_admin_headers, data=json.dumps(zone_data), content_type="application/json") data = res.get_json(force=True) data['rrsets'] = [] validate_zone(data) assert res.status_code == 201
def test_new_user_login(client, mocker, session): # noqa mocker.patch('rr.queries.user_by_fb_id', side_effect=no_existing_user) requests_get_mock = mocker.patch('requests.get', side_effect=MockResponse( 200, graph_me_with_friends)) data = {'timezone': 'US/Pacific', 'access_token': '123'} res = client.post(flask.url_for('auth.login'), data=json.dumps(data), headers={'Content-Type': 'application/json'}) url = ('https://graph.facebook.com/me?fields=id,name,picture,' 'friends&access_token={}').format(data['access_token']) requests_get_mock.assert_called_with(url) u = session.query(User).one() # login # FIXME # assert flask.session.get('user_id') == str(u.id) # request succeeded assert res.status_code == 200
def test_existing_user_login(client, session, mocker): # noqa existing, friend_one, friend_two = seed_existing_users() session.add_all([existing, friend_one, friend_two]) session.commit() assert existing.all_friends == [] mocker.patch('requests.get', MockResponse(200, graph_me_with_friends)) mocker.patch('rr.queries.user_by_fb_id', no_existing_user) data = {'timezone': 'US/Pacific', 'access_token': '123'} res = client.post(flask.url_for('auth.login'), data=json.dumps(data), headers={'Content-Type': 'application/json'}) # no new users created assert session.query(User).count() == 3 # fb access token updated assert existing.fb_access_token == '123' # friends updated assert set(existing.friends) == set([friend_one, friend_two])
def post_game(client, session_id, data={}, expected_response=200): response = client.post('/session/{}/game/'.format(session_id), data=json.dumps(data), content_type='application/json') assert response.status_code == expected_response return response
def test_account_users( self, client, initial_data, # noqa: F811 account_data, user1_data, # noqa: F811 basic_auth_admin_headers, basic_auth_user_headers): # noqa: F811 self.client = client self.basic_auth_admin_headers = basic_auth_admin_headers # Create account res = client.post( "/api/v1/pdnsadmin/accounts", headers=basic_auth_admin_headers, data=json.dumps(account_data), content_type="application/json", ) data = res.get_json(force=True) assert res.status_code == 201 # Check account data = self.check_account(account_data) account_id = data["id"] # Create user1 res = client.post( "/api/v1/pdnsadmin/users", headers=basic_auth_admin_headers, data=json.dumps(user1_data), content_type="application/json", ) data = res.get_json(force=True) assert res.status_code == 201 assert len(data) == 1 # Check user user1 = self.check_user(user1_data, data[0]) user1_id = user1["id"] # Assert test account has no users res = client.get( "/api/v1/pdnsadmin/accounts/users/{}".format(account_id), headers=basic_auth_admin_headers, content_type="application/json", ) data = res.get_json(force=True) assert res.status_code == 200 assert data == [] # Link user to account (as user, should fail) res = client.put( "/api/v1/pdnsadmin/accounts/users/{}/{}".format( account_id, user1_id), headers=basic_auth_user_headers, content_type="application/json", ) assert res.status_code == 401 # Link user to account (as admin) res = client.put( "/api/v1/pdnsadmin/accounts/users/{}/{}".format( account_id, user1_id), headers=basic_auth_admin_headers, content_type="application/json", ) assert res.status_code == 204 # Unlink user from account (as user, should fail) res = client.delete( "/api/v1/pdnsadmin/accounts/users/{}/{}".format( account_id, user1_id), headers=basic_auth_user_headers, content_type="application/json", ) assert res.status_code == 401 # Unlink user from account (as admin) res = client.delete( "/api/v1/pdnsadmin/accounts/users/{}/{}".format( account_id, user1_id), headers=basic_auth_admin_headers, content_type="application/json", ) assert res.status_code == 204 # Cleanup (delete user) res = client.delete( "/api/v1/pdnsadmin/users/{}".format(user1_id), data=json.dumps(user1_data), headers=basic_auth_admin_headers, content_type="application/json", ) assert res.status_code == 204 # Cleanup (delete account) res = client.delete( "/api/v1/pdnsadmin/accounts/{}".format(account_id), data=json.dumps(account_data), headers=basic_auth_admin_headers, content_type="application/json", ) assert res.status_code == 204