Exemple #1
0
def test_sms_send4(session, guest_logged):
    """Test sms_send view by calling with same phone/device more than bi-hourly limit

     """
    site1 = Wifisite.query.filter_by(unifi_id="site1").first()
    guest_track = Guesttrack.query.first()
    guest_device = Device.query.first()

    msg = {"status": 1, "msg": "Code has been send to the mobile"}
    url = url_for("guest.sms_send", track_id=guest_track.track_id)
    result = current_app.test_client().post(url, follow_redirects=True, data={"phonenumber": "+123456780"})
    assert msg == result.json, "Found msg :%s instead of :%s  while trying to send SMS" % (result.json, msg)
    # fake limit over
    smsdata = Smsdata.query.first()
    smsdata.send_try = 6
    db.session.commit()
    result = current_app.test_client().post(url, follow_redirects=True, data={"phonenumber": "+123456780"})
    wait_msg = "Looks like SMS network is having issues,please wait for"
    assert wait_msg in result.json["msg"], "Found msg :%s instead of :%s  while trying to send SMS" % (
        result.json["msg"],
        wait_msg,
    )
    # recovering after 2hrs
    smsdata.timestamp = arrow.utcnow().replace(hours=-2).naive
    db.session.commit()
    result = current_app.test_client().post(url, follow_redirects=True, data={"phonenumber": "+123456780"})
    assert msg == result.json, "Found msg :%s instead of :%s  while trying to send SMS" % (result.json, msg)
    assert 1 == Smsdata.query.first().send_try, "Smsdata.send_try is not resetting after 2 hrs"
 def test_user(self):
     test_user = User.query.filter_by(userName='******').first()
     user_info = test_user.to_json()
     for i in list(user_info.keys()):
         user_info[i] = str(user_info[i])
     user_info['token'] = test_user.generate_auth_token(3600 * 24 * 30)
     response = current_app.test_client().post(
         url_for('api.query_by_id', id=test_user.id),\
             headers={'Accept': 'application/json', 'Content-Type': 'application/json'}, \
             data=json.dumps(user_info) )
     # response code 400
     self.assertEqual(200, response.status_code)
     response2 = current_app.test_client().get(
         url_for('api.get_user_activities',id=test_user.id),
     )
     self.assertEqual(200,response2.status_code)
     apply_info = {
         "id":1,
         "content": "",
         "token": user_info['token']
     }
     response3 = current_app.test_client().post(
         url_for('api.user_apply',id=test_user.id),
         headers={'Accept': 'application/json', 'Content-Type': 'application/json'},
         data=json.dumps(apply_info)
     )
     self.assertEqual(200,response3.status_code)
     response4 = current_app.test_client().get(
         url_for('api.get_user_messages',id=test_user.id),
     )
     self.assertEqual(200,response4.status_code)
Exemple #3
0
def test_sms_send3(session, guest_logged):
    """Test sms_send view by calling with same phone/device multiple times

     """
    site1 = Wifisite.query.filter_by(unifi_id="site1").first()
    guest_track = Guesttrack.query.first()
    guest_device = Device.query.first()

    msg = {"status": 1, "msg": "Code has been send to the mobile"}
    url = url_for("guest.sms_send", track_id=guest_track.track_id)
    result = current_app.test_client().post(url, follow_redirects=True, data={"phonenumber": "+123456780"})
    assert msg == result.json, "Found msg :%s instead of :%s  while trying to send SMS" % (result.json, msg)

    # immediate calling without delay
    msg_wait = {"status": 0, "msg": "Wait for atleast 30sec before trying again"}
    result = current_app.test_client().post(url, follow_redirects=True, data={"phonenumber": "+123456780"})
    assert msg_wait == result.json, "Found msg :%s instead of :%s  while trying to send SMS" % (result.json, msg_wait)
    # fake 30sec over
    smsdata = Smsdata.query.first()
    smsdata.timestamp = arrow.utcnow().replace(seconds=-31).naive
    db.session.commit()
    result = current_app.test_client().post(url, follow_redirects=True, data={"phonenumber": "+123456780"})
    assert msg == result.json, "Found msg :%s instead of :%s  while trying to send SMS" % (result.json, msg)

    assert 1 == Smsdata.query.count(), "Smsdata is not created even after providing valid phonenumber"
    assert 2 == Smsdata.query.first().send_try, "Smsdata.send_try is not increamented after two trials"
Exemple #4
0
    def test_invite_collaborator(self):
        video = Video.query.get(1)
        token = self._send_collaborator_token(video)

        # Check that collaborator can access video with token
        with current_app.test_client() as client:
            r = client.post('/api/validate_token', data=dict(token=token))
            self.assertEquals(r.status_code, 200)
            self.assertEquals(r.json()['display_name'], 'test')

            with patch('wonder.romeo.core.dolly.DollyUser.get_userdata') as get_userdata:
                get_userdata.return_value = dict(
                    display_name='test',
                    description='',
                    avatar_thumbnail_url='',
                    profile_cover_url='',
                )
                r = client.get('/api/video/%d' % video.id)
                self.assertEquals(r.status_code, 200)
                self.assertEquals(r.json()['account']['name'], 'account1')

        # Same request for anonymous should fail
        with current_app.test_client() as client:
            r = client.get('/api/video/%d' % video.id)
            self.assertEquals(r.status_code, 401)
    def test_mess(self):
        test_user = User.query.filter_by(userName='******').first()
        test_activity = Activity.query.filter_by(AID='998').first()

        test_ua = UserActivity(user=test_user, applyTime='2017-04-09', content="test ua", activity=test_activity,
                                  type='applied')
        test_mess = Message(user=test_user, activity=test_activity,
                            content="test message", time='2017-04-09', isRead=False)

        db.session.add_all([test_mess, test_ua])
        db.session.commit()

        mess_info = {"token": test_user.generate_auth_token(expiration=3600 * 24 * 30)}
        response = current_app.test_client().post(
            url_for('api.change_message_isread', id=test_mess.id),
            headers={'Accept': 'application/json', 'Content-Type': 'application/json'},
            data=json.dumps(mess_info))
        self.assertEqual(200, response.status_code)

        response = current_app.test_client().post(
            url_for('api.delete_message', id=test_mess.id),
            headers={'Accept': 'application/json', 'Content-Type': 'application/json'},
            data=json.dumps(mess_info))
        self.assertIsNone(Message.query.filter_by(content="test message").first())
        self.assertEqual(200, response.status_code)

        Message.query.filter_by(content="test message").delete()
        UserActivity.query.filter_by(content="test ua").delete()
        db.session.commit()
def test_guest_session_bypass_auth1(session):
    '''User who have visited couple of times during the session, visits again after session expiry
    
    '''
    device_mac      = '00:de:ad:be:ef:ca'
    ap_mac          = '00:22:00:00:00:01'
    site            = Wifisite.query.filter_by(unifi_id='site2').first() 
   
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status

    ##-------------Expire the current session for this user-------------------------------------------
    gsession        = Guestsession.query.filter( and_(Guestsession.mac==device_mac,Guestsession.site_id==site.id)).first()   
    gsession.state  = SESSION_EXPIRED
    session.commit()

    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    
    num_guesttrack  = Guesttrack.query.filter( and_(Guesttrack.site_id==site.id)).count()
    num_session = Guestsession.query.filter( and_(Guestsession.site_id==site.id)).count()
    num_device  = Device.query.filter( and_(Device.site_id==site.id)).count()
    num_guest  = Guest.query.filter( and_(Guest.site_id==site.id)).count()
    
    assert num_guesttrack == 5 ,"Guesttrack entries not equal to the number of visits:%s"%num_guesttrack
    assert num_session == 2 ,"Guestsession entries not equal to the number of sessions"
    assert num_device == 1 ,"Device entries not equal to the number of unique Devices"
    assert num_guest == 1 ,"Guest entries not equal to the number of unique Devices"
def test_email_login1(session):
    '''Email login with invalid parameters and authorized device
    
    '''
    device_mac      = '00:de:ad:be:ef:da'
    ap_mac          = '00:22:00:00:00:01'
    site            = Wifisite.query.filter_by(unifi_id='site3').first() 
   
    #invalid track ID
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/email/guest/67yte7ey51wy167w2816i2351835').status

    #test valid trackid but no session
    track_id = str(uuid.uuid4())
    guest_track = Guesttrack(ap_mac=ap_mac,device_mac=device_mac,site=site,state=GUESTRACK_INIT,orig_url='',track_id=track_id)
    session.add(guest_track)
    session.commit()
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/email/check/%s'%track_id).status
    #create session but no device
    guest_session = Guestsession(mac=device_mac,state=SESSION_INIT,site=site)
    session.add(guest_session)
    site.sessions.append(guest_session)
    guest_track.session = guest_session
    guest_session.guesttracks.append(guest_track)
    guest_track.state = GUESTRACK_SESSION    
    session.commit()
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/email/guest/%s'%track_id).status
    #with session and authorized device
    guest_device = Device(mac=device_mac,site=site,state=DEVICE_AUTH)
    site.devices.append(guest_device)
    session.add(guest_device)
    guest_device.sessions.append(guest_session) 
    session.commit()
    assert '/guest/auth/guest/%s'%track_id in current_app.test_client().get('/guest/email/guest/%s'%track_id).data
    assert guest_session.state == SESSION_AUTHORIZED
    assert   guest_track.state   == GUESTRACK_SOCIAL_PREAUTH
Exemple #8
0
def test_sms_send3(session,guest_logged):
    '''Test sms_send view by calling with same phone/device multiple times

     '''    
    site1           = Wifisite.query.filter_by(unifi_id='site1').first() 
    guest_track     = Guesttrack.query.first()
    guest_device    = Device.query.first()   
    
    msg= {'status':1,'msg':"Code has been send to the mobile"}
    url = url_for('guest.sms_send',track_id=guest_track.track_id) 
    result = current_app.test_client().post(url,follow_redirects=True,data={'phonenumber':'+123456780'}) 
    assert msg == result.json ,\
            'Found msg :%s instead of :%s  while trying to send SMS'%(result.json,msg) 

    #immediate calling without delay
    msg_wait = {'status':0,'msg':"Wait for atleast 30sec before trying again"}
    result = current_app.test_client().post(url,follow_redirects=True,data={'phonenumber':'+123456780'}) 
    assert msg_wait == result.json ,\
            'Found msg :%s instead of :%s  while trying to send SMS'%(result.json,msg_wait) 
    #fake 30sec over
    smsdata = Smsdata.query.first()
    smsdata.timestamp = arrow.utcnow().replace(seconds=-31).naive
    db.session.commit()
    result = current_app.test_client().post(url,follow_redirects=True,data={'phonenumber':'+123456780'}) 
    assert msg == result.json ,\
            'Found msg :%s instead of :%s  while trying to send SMS'%(result.json,msg) 

    assert 1 == Smsdata.query.count() , "Smsdata is not created even after providing valid phonenumber"
    assert 2 == Smsdata.query.first().send_try , "Smsdata.send_try is not increamented after two trials"
Exemple #9
0
    def test_register(self):
        if IntroCode.query.filter_by(code="12345678").first() is None:
            new_intro_code = IntroCode(code="12345678")
            db.session.add(new_intro_code)
            db.session.commit()
        self.assertIsNotNone(IntroCode.query.filter_by(code="12345678").first())

        data = {"introcode": "12345678", "email": "test@register",
                "username": "******", "password": "******","password2":"test_user_pw"}

        response = current_app.test_client().post(
            url_for('auth.register'),
            data=data
        )
        json_data = response.data

        time.sleep(2)

        new_team = Team.query.filter_by(email="test@register").first()
        self.assertIsNotNone(new_team)

        response = current_app.test_client().get(url_for('auth.logout'))
        self.assertIsNotNone(response)

        Team.query.filter_by(email="test@register").delete()
        IntroCode.query.filter_by(code="12345678").delete()
        db.session.commit()
def test_facebook_login1(session):
    '''Facebook login with invalid parameters and no fb cookies
    
    '''
    device_mac      = '00:de:ad:be:ef:da'
    ap_mac          = '00:22:00:00:00:01'
    site            = Wifisite.query.filter_by(unifi_id='site1').first() 
   
    #invalid track ID
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/facebook/check/67yte7ey51wy167w2816i2351835').status

    #test valid trackid but no session
    track_id = str(uuid.uuid4())
    guest_track = Guesttrack(ap_mac=ap_mac,device_mac=device_mac,site=site,state=GUESTRACK_INIT,orig_url='',track_id=track_id)
    db.session.add(guest_track)
    db.session.commit()
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/facebook/check/%s'%track_id).status
    #create session but no device
    guest_session = Guestsession(mac=device_mac,state=SESSION_INIT,site=site)
    db.session.add(guest_session)
    site.sessions.append(guest_session)
    guest_track.session = guest_session
    guest_session.guesttracks.append(guest_track)
    guest_track.state = GUESTRACK_SESSION    
    db.session.commit()
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/facebook/check/%s'%track_id).status
    #with session and authorized device
    guest_device = Device(mac=device_mac,site=site,state=DEVICE_INIT)
    site.devices.append(guest_device)
    db.session.add(guest_device)
    guest_device.sessions.append(guest_session) 
    db.session.commit()
Exemple #11
0
def test_sms_send4(session,guest_logged):
    '''Test sms_send view by calling with same phone/device more than bi-hourly limit

     '''    
    site1           = Wifisite.query.filter_by(unifi_id='site1').first() 
    guest_track     = Guesttrack.query.first()
    guest_device    = Device.query.first()   
    
    msg= {'status':1,'msg':"Code has been send to the mobile"}
    url = url_for('guest.sms_send',track_id=guest_track.track_id) 
    result = current_app.test_client().post(url,follow_redirects=True,data={'phonenumber':'+123456780'}) 
    assert msg == result.json ,\
            'Found msg :%s instead of :%s  while trying to send SMS'%(result.json,msg) 
    #fake limit over
    smsdata = Smsdata.query.first()       
    smsdata.send_try = 6     
    db.session.commit()
    result = current_app.test_client().post(url,follow_redirects=True,data={'phonenumber':'+123456780'}) 
    wait_msg = 'Looks like SMS network is having issues,please wait for'
    assert wait_msg in result.json['msg'] ,\
            'Found msg :%s instead of :%s  while trying to send SMS'%(result.json['msg'],wait_msg) 
    #recovering after 2hrs
    smsdata.timestamp = arrow.utcnow().replace(hours=-2).naive
    db.session.commit()
    result = current_app.test_client().post(url,follow_redirects=True,data={'phonenumber':'+123456780'}) 
    assert msg == result.json ,\
            'Found msg :%s instead of :%s  while trying to send SMS'%(result.json,msg)     
    assert 1 == Smsdata.query.first().send_try , "Smsdata.send_try is not resetting after 2 hrs"
Exemple #12
0
def test_social_login(session):
    '''User who have visited couple of times during the session, visits again after session expiry
    
    '''
    device_mac      = '00:de:ad:be:ef:ca'
    ap_mac          = '00:22:00:00:00:01'
    site            = Wifisite.query.filter_by(unifi_id='site2').first() 
   
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status

    ##-------------Expire the current session for this user-------------------------------------------
    gsession        = Guestsession.query.filter( and_(Guestsession.mac==device_mac,Guestsession.site_id==site.id)).first()   
    gsession.state  = SESSION_EXPIRED
    session.commit()

    assert '302 FOUND' == current_app.test_client().get('/guest/s/site2/?id=00:de:ad:be:ef:ca&ap=00:22:00:00:00:01').status
    
    num_guesttrack  = Guesttrack.query.filter( and_(Guesttrack.site_id==site.id)).count()
    num_session = Guestsession.query.filter( and_(Guestsession.site_id==site.id)).count()
    num_device  = Device.query.filter( and_(Device.site_id==site.id)).count()
    num_guest  = Guest.query.filter( and_(Guest.site_id==site.id)).count()
    
    assert num_guesttrack == 5 ,"Guesttrack entries not equal to the number of visits:%s"%num_guesttrack
    assert num_session == 2 ,"Guestsession entries not equal to the number of sessions"
    assert num_device == 1 ,"Device entries not equal to the number of unique Devices"
    assert num_guest == 1 ,"Guest entries not equal to the number of unique Devices"
def test_guest_invalid_values(session):
    # print "sleep 20"
  
    #test for all parameters (id and ap_mac) given by coming user
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/s/site1/').status
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/s/site1/?ap=00:01:00:00:00:11').status
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/s/site1/?id=00:de:ad:be:ef:ca').status
    assert '404 NOT FOUND' == current_app.test_client().get('/guest/s/error/?id=00:de:ad:be:ef:ca&ap=00:01:00:00:00:11').status
def test_sync_unhandled_exception():
    old_throttle = pypi.THROTTLE
    pypi.THROTTLE = 'nan'
    redis.delete(POLL_SIMPLE_THROTTLE)

    with pytest.raises(ValueError):
        current_app.test_client().get('/pypi/sync').status()

    pypi.THROTTLE = old_throttle
Exemple #15
0
def test_sync_unhandled_exception():
    old_throttle = pypi.THROTTLE
    pypi.THROTTLE = 'nan'
    redis.delete(POLL_SIMPLE_THROTTLE)

    with pytest.raises(ValueError):
        current_app.test_client().get('/pypi/sync').status()

    pypi.THROTTLE = old_throttle
Exemple #16
0
    def setUp(self):
        self.app = current_app.test_client();
        self.requestHelper = RequestsHelper(current_app.test_client(), 'api/patients')

        service = Service(name='service api', price='1500')
        service2 = Service(name='service api2', price='1200')
        service3 = Service(name='service api3', price='3520')
        db.session.add(service)
        db.session.add(service2)
        db.session.add(service3)
        db.session.commit()
Exemple #17
0
    def setUp(self):
        self.app = current_app.test_client();

        self.requestHelper = RequestsHelper(current_app.test_client(), 'api/users')

        user = User(password='******', name='user api', userName='******')
        user2 = User(password='******', name='user api2', userName='******')
        user3 = User(password='******', name='user api3', userName='******')
        db.session.add(user)
        db.session.add(user2)
        db.session.add(user3)
        db.session.commit()
Exemple #18
0
    def setUp(self):
        self.app = current_app.test_client();

        self.requestHelper = RequestsHelper(current_app.test_client(), 'api/rooms')

        room = Room(name='room api')
        room2 = Room(name='room api2')
        room3 = Room(name='room api3')
        db.session.add(room)
        db.session.add(room2)
        db.session.add(room3)
        db.session.commit()
Exemple #19
0
def test_guest_invalid_values(session):
    # print "sleep 20"

    #test for all parameters (id and ap_mac) given by coming user
    assert '404 NOT FOUND' == current_app.test_client().get(
        '/guest/s/site1/').status
    assert '404 NOT FOUND' == current_app.test_client().get(
        '/guest/s/site1/?ap=00:01:00:00:00:11').status
    assert '404 NOT FOUND' == current_app.test_client().get(
        '/guest/s/site1/?id=00:de:ad:be:ef:ca').status
    assert '404 NOT FOUND' == current_app.test_client().get(
        '/guest/s/error/?id=00:de:ad:be:ef:ca&ap=00:01:00:00:00:11').status
Exemple #20
0
    def setUp(self):
        self.app = current_app.test_client();
        self.requestHelper = RequestsHelper(current_app.test_client(), 'api/patients')

        patient = Patient(name='patient api', mobileNumber='11111111111')
        patient2 = Patient(name='patient api2', mobileNumber='121212211212')
        patient3 = Patient(name='patient api3', mobileNumber='3223232323')
        db.session.add(patient)
        db.session.add(patient2)
        db.session.add(patient3)
        db.session.commit()

        pass
Exemple #21
0
    def setUp(self):
        self.app = current_app.test_client()
        self.requestHelper = RequestsHelper(current_app.test_client(), "api/patients")

        patient = Patient(name="patient api", mobileNumber="11111111111")
        patient2 = Patient(name="patient api2", mobileNumber="121212211212")
        patient3 = Patient(name="patient api3", mobileNumber="3223232323")
        db.session.add(patient)
        db.session.add(patient2)
        db.session.add(patient3)
        db.session.commit()

        pass
Exemple #22
0
    def setUp(self):
        self.repo = self.create_repo(
            url='https://github.com/dropbox/changes.git',
        )
        self.project = self.create_project(
            repository=self.repo,
            name='test',
            slug='test'
        )
        self.project2 = self.create_project(
            repository=self.repo,
            name='test2',
            slug='test2',
        )

        self.plan = self.create_plan()
        self.plan.projects.append(self.project)
        db.session.commit()

        # mock out mail
        mail_context = mail.record_messages()
        self.outbox = mail_context.__enter__()
        self.addCleanup(lambda: mail_context.__exit__(None, None, None))

        self.client = app.test_client()

        super(TestCase, self).setUp()
Exemple #23
0
 def setUp(self):
     db.create_all()
     for datum in good_data:
         asset = Asset(**datum)
         db.session.add(asset)
     db.session.commit()
     self.client = current_app.test_client()
Exemple #24
0
    def http_call(self, url, method, **kwargs):
        """Fakes a http call through Flask/Werkzeug."""
        client = current_app.test_client()
        self.requests_to_flask_kwargs(kwargs)

        # Leave out the query string and fragment from the URL.
        split_url = urllib.parse.urlsplit(url)
        path = urllib.parse.urlunsplit(split_url[:-2] + (None, None))
        try:
            response = client.open(path=path,
                                   query_string=split_url.query,
                                   method=method,
                                   **kwargs)
        except Exception as ex:
            log.warning('Error performing HTTP %s request to %s: %s', method,
                        url, str(ex))
            raise

        if method == 'OPTIONS':
            return response

        self.flask_to_requests_response(response)

        try:
            content = self.handle_response(response, response.data)
        except:
            log.warning("%s: Response[%s]: %s", url, response.status_code,
                        response.data)
            raise

        return content
Exemple #25
0
def datapackage_show(owner, id):
    """
    Loads datapackage page for given owner 
    ---
    tags:
      - site
    parameters:
      - name: owner
        in: path
        type: string
        required: true
        description: datapackage owner name
      - name: id
        in: path
        type: string
        description: datapackage name
    responses:
      404:
        description: Datapackage does not exist
      200:
        description: Succesfuly loaded
    """
    metadata = json.loads(app.test_client().get('/api/{owner}/{id}'.format(
        owner=owner, id=id)).data)
    if metadata['status'] == 'KO':
        return "404 Not Found", 404
    dataset = metadata['data']
    resources = dataset['resources']
    dataViews = dataset['views'] or []

    return render_template("dataset.html",
                           dataset=dataset,
                           showDataApi=True,
                           jsonDataPackage=dataset,
                           dataViews=dataViews), 200
Exemple #26
0
    def _write_loaded_data(self):
        client = current_app.test_client()

        url = "/api/slicer/cube/geometry/cubes_aggregate?cubes=" + self.dataset.name + "&drilldown=geometry__time|geometry__country_level0@name&format=csv"

        with client:
            # Fill in your details here to be posted to the login form.
            LOCKDOWN_FORCE = current_app.config.get("LOCKDOWN_FORCE", False)
            LOCKDOWNUSER = current_app.config.get("LOCKDOWNUSER")
            LOCKDOWNPASSWORD = current_app.config.get("LOCKDOWNPASSWORD")
            if LOCKDOWN_FORCE:
                payload = {
                    'username': LOCKDOWNUSER,
                    'password': LOCKDOWNPASSWORD
                }

                client.post(url_for('home.lockdown'),
                            data=payload,
                            follow_redirects=True)

            try:
                postloadvalue = client.get(url, follow_redirects=True).data
            except Exception, e:
                log.warn("Could Not find post load content for " +
                         dataset.name)
Exemple #27
0
def test_authenticate_sms5(session, guest_logged):
    """Test authenticate_sms view by posting correctly

     """
    site1 = Wifisite.query.filter_by(unifi_id="site1").first()
    guest_track = Guesttrack.query.first()
    guest_device = Device.query.first()

    phonenumber = "+123456789"
    smsdata = Smsdata(phonenumber=phonenumber, device=guest_device)
    db.session.add(smsdata)
    guest_device.smsdatas.append(smsdata)
    smsdata.authcode = random.randrange(10000, 99999, 1)
    db.session.commit()
    url = url_for("guest.authenticate_sms", track_id=guest_track.track_id)

    result = current_app.test_client().post(
        url, follow_redirects=False, data={"phonenumber": phonenumber, "authcode": smsdata.authcode}
    )
    auth_url = url_for("guest.multi_login", track_id=guest_track.track_id, _external=True)
    assert auth_url == result.location, "UE gets redirected to :%s instead of expected :%s" % (
        result.location,
        auth_url,
    )

    assert 1 == guest_device.sms_confirm, "sms_confirm is not set after submit"
def test_add_data():
    httpretty.register_uri(httpretty.GET,
                           re.compile('.*/commits'),
                           status=200,
                           body=json.dumps([
                               {
                                   'author': {
                                       'login': '******'
                                   },
                                   'commit': {
                                       'message': 'New setup.py.'
                                   }
                               },
                               {
                                   'author': {
                                       'login': '******'
                                   },
                                   'commit': {
                                       'message': 'Old setup.py.'
                                   }
                               },
                           ]))
    httpretty.register_uri(httpretty.GET,
                           re.compile('.*/contributors'),
                           status=200,
                           body='[{"weeks": [{"a": 1}]}]')

    assert '200 OK' == current_app.test_client().post(
        '/api/query_github', data=dict(repo_url='1/2')).status
    expected = [('1/2', 1, 'Myself You', 'New setup.py.')]
    actual = db.session.query(Repository.url, Repository.line_count,
                              Repository.top_committers,
                              Repository.last_commit).all()
    assert expected == actual
Exemple #29
0
    def setUp(self):
        self.repo = self.create_repo(
            url='https://github.com/dropbox/changes.git',
        )
        self.project = self.create_project(
            repository=self.repo,
            name='test',
            slug='test'
        )
        self.project2 = self.create_project(
            repository=self.repo,
            name='test2',
            slug='test2',
        )

        self.plan = self.create_plan()
        self.plan.projects.append(self.project)
        db.session.commit()

        # mock out mail
        mail_context = mail.record_messages()
        self.outbox = mail_context.__enter__()
        self.addCleanup(lambda: mail_context.__exit__(None, None, None))

        self.client = app.test_client()

        super(TestCase, self).setUp()
def test_social_login2(session):
    '''Social login with unauthorized device
    
    '''
    device_mac      = '00:de:ad:be:ef:ca'
    ap_mac          = '00:22:00:00:00:01'
    site            = Wifisite.query.filter_by(unifi_id='site1').first() 
   
    #test valid trackid but no session
    track_id = str(uuid.uuid4())
    guest_track = Guesttrack(ap_mac=ap_mac,device_mac=device_mac,site=site,state=GUESTRACK_INIT,orig_url='',track_id=track_id)
    db.session.add(guest_track)
    db.session.commit()
    #create session 
    guest_session = Guestsession(mac=device_mac,state=SESSION_INIT,site=site)
    db.session.add(guest_session)
    site.sessions.append(guest_session)
    guest_track.session = guest_session
    guest_session.guesttracks.append(guest_track)
    guest_track.state = GUESTRACK_SESSION    
    db.session.commit()
    #with session and unauthorized device
    guest_device = Device(mac=device_mac,site=site,state=DEVICE_INIT)
    site.devices.append(guest_device)
    db.session.add(guest_device)
    guest_device.sessions.append(guest_session)
    db.session.commit()
    assert '200 OK' == current_app.test_client().get('/guest/social/guest/%s'%track_id).status
    assert guest_session.state == SESSION_TEMP_AUTH    
Exemple #31
0
def test_social_login2(session):
    '''Social login with unauthorized device
    
    '''
    device_mac = '00:de:ad:be:ef:ca'
    ap_mac = '00:22:00:00:00:01'
    site = Wifisite.query.filter_by(unifi_id='site1').first()

    #test valid trackid but no session
    track_id = str(uuid.uuid4())
    guest_track = Guesttrack(ap_mac=ap_mac,
                             device_mac=device_mac,
                             site=site,
                             state=GUESTRACK_INIT,
                             orig_url='',
                             track_id=track_id)
    db.session.add(guest_track)
    db.session.commit()
    #create session
    guest_session = Guestsession(mac=device_mac, state=SESSION_INIT, site=site)
    db.session.add(guest_session)
    site.sessions.append(guest_session)
    guest_track.session = guest_session
    guest_session.guesttracks.append(guest_track)
    guest_track.state = GUESTRACK_SESSION
    db.session.commit()
    #with session and unauthorized device
    guest_device = Device(mac=device_mac, site=site, state=DEVICE_INIT)
    site.devices.append(guest_device)
    db.session.add(guest_device)
    guest_device.sessions.append(guest_session)
    db.session.commit()
    assert '200 OK' == current_app.test_client().get('/guest/social/guest/%s' %
                                                     track_id).status
    assert guest_session.state == SESSION_TEMP_AUTH
 def setUp(self):
     self.app = create_app('testing')
     self.ctx = self.app.app_context()
     self.ctx.push()
     self.client = current_app.test_client()
     self.db = db
     self.db.create_all()
Exemple #33
0
    def setUp(self):
        self.client = current_app.test_client()

        if not self.gen_data:
            response = self.client.post(
                'http://localhost:5000/api/busers/session',
                data=json.dumps({
                    "username": "******",
                    "password": "******",
                }))
            self.assertTrue("Successfully login." in response.get_data(
                as_text=True))

            for promotion in self.promotions:
                response = self.client.post(
                    'http://localhost:5000/api/promotions/',
                    data=json.dumps(promotion))
                # print(response.get_data(as_text=True))
                self.assertTrue(response.status_code == 200)

            response = self.client.post(
                'http://localhost:5000/api/promotions/1/rules',
                data=json.dumps({
                    'mode': 1,
                    'requirement': 100,
                    'discount': 10
                }))
            self.assertTrue(response.status_code == 200)

            # 退出
            response = self.client.put(
                'http://localhost:5000/api/busers/session')

            self.gen_data = True
Exemple #34
0
def update(key, name, owner, code, private, locked):
    collection = Collection.objects(key=key).first()
    old_code = collection.code

    if name:
        collection.name = name
    if owner:
        collection.owner = owner
    if code:
        collection.code = code
    if private is not None:
        collection.private = private
    if locked is not None:
        collection.locked = locked

    try:
        collection.save()
    except exceptions.NotUniqueError:
        msg = f"Short code is already taken: {collection.code}"
        raise exceptions.UnprocessableEntity(msg)
    except exceptions.ValidationError as exc:
        msg = list(exc.to_dict().values())[0]
        raise exceptions.UnprocessableEntity(msg)

    if old_code and old_code != collection.code:
        data = {'start_slug': old_code, 'end_slug': collection.code}
        result = current_app.test_client().post("/api/redirects/", data=data)
        log.debug(result)

    return serialize(collection), status.HTTP_200_OK
def create_notification(title, description, user):
    """Create a new notification"""
    try:
        notification = {
            "title": title,
            "description": description,
            "user": user
        }
        resp = app.test_client().post('/'+app.config['API_VERSION']+'/notifications/', data=toJSON(notification), content_type='application/json')
        if int(resp.status_code)/100 == 2:
            logger.debug("Notification created successfully")
        else:
            logger.debug("Notification creation failed")
            raise Exception("Notification creation failed")
    except Exception as e:
        # TODO: handle exceptions
        logger.error("Error creating notification: " + str(e), exc_info=1)
        return 1
    return 0

 
# # Execute a function call in thread
# def threaded(call, *args, **kwargs):
#     """Execute ``call(*args, **kwargs)`` in a thread"""
#     thread = threading.Thread(target=call, args=args, kwargs=kwargs)
#     thread.start()
#     return thread

# def is_main_thread_active():
#     return any((i.name == "MainThread") and i.is_alive() for i in threading.enumerate())
Exemple #36
0
def get_response_from_view(url, auth=None, data=None, as_json=False):
    # https://stackoverflow.com/a/21342070/10517783  How do I call one Flask view from another one?
    # https://stackoverflow.com/a/30250045/10517783
    # python - Flask test_client() doesn't have request.authorization with pytest
    client = app.test_client()
    if auth is not None:
        headers = {'Authorization': basic_auth_header(*auth)}
    else:
        headers = {}
    if data is not None:
        response = client.post(url, headers=headers, data=data, content_type='multipart/form-data')
    else:
        response = client.get(url, headers=headers)

    text = response.get_data(as_text=True)
    if as_json:
        # e.g. when used in schedule_task()
        # 'node index error: %s, which should be between 1 and %s' % (self.node, self.SCRAPYD_SERVERS_AMOUNT)
        # json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)
        try:
            return json.loads(text)
        except ValueError:
            # '_status': '500 INTERNAL SERVER ERROR',
            # '_status_code': 500,
            # See 500.html
            # <tr><th>Error</th><td>node index error: 2, which should be between 1 and 1</td></tr>
            # <pre>Traceback...AssertionError: node index error: 2, which should be between 1 and 1 </pre>
            m = re.search(r'<tr><th>Error</th><td>(.+?)</td></tr>', text, re.S)
            message = m.group(1) if m else text
            return dict(status_code=getattr(response, '_status_code', 500), status='error', message=message)
    else:
        return text
Exemple #37
0
def check_facebook_login_page(url):
    ''' Visit the URL and follow directs, and ensure that page returned have FB login form'''
    result = current_app.test_client().get(url, follow_redirects=True)
    assert '200 OK' == result.status, 'Current user  getting:%s instead of  200 OK while trying to View URL:%s' % (
        result.status, url)
    assert 'Login Using Facebook' in result.data,\
            'Facebook Login button not seen  check_facebook_login_page at  URL:%s'%(url)
Exemple #38
0
def test_authorize_guest2(session):
    """ authorize_guest check if parameters are correctly configured """
    # create a guest visitor
    site1 = Wifisite.query.filter_by(id=1).first()
    mac = randomMAC()
    ap_mac = randomMAC()
    site1.auth_method = AUTH_TYPE_SOCIAL + AUTH_TYPE_SMS + AUTH_TYPE_EMAIL + AUTH_TYPE_VOUCHER
    db.session.commit()
    url = get_guest_url(site1, mac, ap_mac, demo=0)
    check_multi_login_page(url)

    guest_track = Guesttrack.query.first()

    # authorize session
    guest_track.state = GUESTRACK_SOCIAL_AUTH

    auth_url = url_for("guest.authorize_guest", track_id=guest_track.track_id)
    result = current_app.test_client().get(auth_url, follow_redirects=True)
    assert "200 OK" == result.status, "authorize_guest  getting:%s instead of  200 OK while trying to View URL:%s" % (
        result.status,
        url,
    )

    # check if guest_session is created
    guest_session = Guestsession.query.first()
    assert isinstance(guest_session, Guestsession), "Guestsession is not created when calling authorize_guest"
    assert guest_session.state == GUESTRACK_SOCIAL_AUTH, " guest_session state is not GUESTRACK_SOCIAL_AUTH"
Exemple #39
0
def oembed(url):
    path = urlparse(url).path + "?format=json"
    with app.test_client() as c:
        rv = c.get(path)
        try:
            article = loads(rv.data)
        except ValueError:
            print url
            print path
            raise
    if request.args.get("format") == "html":
        return html(article)
    return {
        "success": True,
        "type": "rich",
        "version": "1.0",
        "provider_name": "Venturelog",
        "provider_url": "http://www.venturelog.io",
        "title": article['headline'],
        "author_name": "Brad Smith",
        "author_url": "http://www.venturelog.io",
        "height": "300",
        "width": "800",
        "thumbnail_width": "200",
        "thumbnail_height": str(int(200 * float(3) / 4)),
        "thumbnail_url": thumbUrl(article['thumbnail']),
        "html": html(article)
    }
Exemple #40
0
def test_voucher_login2(session,create_vouchers,guest_logged):
    '''Test voucher_login view with pre authorized guest with non expired voucher

     '''
    site1           = Wifisite.query.filter_by(unifi_id='site1').first() 
    guest_track     = Guesttrack.query.first()
    guest_device    = Device.query.first()
    voucher         = Voucher.query.first()

    #device and used voucher
    used_at = arrow.utcnow().replace(days=2).datetime
    guest_device.state = DEVICE_VOUCHER_AUTH
    voucher.device_id = guest_device.id
    voucher.used = True
    voucher.used_at = used_at    

    #create a session representing old session
    guest_session = Guestsession(site=site1,device=guest_device)
    guest_session.state = GUESTRACK_VOUCHER_AUTH
    guest_session.mac   = guest_device.mac
    guest_session.guesttracks.append(guest_track)
    db.session.add(guest_session)
    guest_track.session_id = guest_session.id  

    #fake variables for session
    guest_session.starttime = used_at
    guest_session.lastseen = used_at
    guest_session.data_used = 500000

    db.session.commit()    

    url = url_for('guest.voucher_login',track_id=guest_track.track_id)      
    result = current_app.test_client().post(url,follow_redirects=False)
    auth_url = url_for('guest.authorize_guest',track_id=guest_track.track_id, _external=True)
    assert auth_url == result.location, "UE gets redirected to :%s instead of expected :%s"%(result.location,auth_url)     
Exemple #41
0
def test_voucher_login5(session,create_vouchers,guest_logged):
    '''Test voucher_login view by entering voucher

     '''
    site1           = Wifisite.query.filter_by(unifi_id='site1').first() 
    guest_track     = Guesttrack.query.first()
    guest_device    = Device.query.first()
    voucher         = Voucher.query.first()
    url = url_for('guest.voucher_login',track_id=guest_track.track_id)   

    firstname   = fake.first_name() 
    lastname    = fake.last_name() 
    email       = fake.email()
    form_data = {'firstname':firstname,'email':email,'lastname':lastname,'voucher':voucher.voucher}    

    result = current_app.test_client().post(url,follow_redirects=False,data=form_data)
    auth_url = url_for('guest.authorize_guest',track_id=guest_track.track_id, _external=True)
    assert auth_url == result.location, "UE gets redirected to :%s instead of expected :%s"%(result.location,auth_url)  
    #check if guest is created
    guest = Guest.query.first().to_dict()
    assert form_data['firstname'] == guest['firstname'],\
            'Guest firstname not matching expected:%s getting:%s'%(form_data['firstname'],guest['firstname'])
    assert form_data['lastname'] == guest['lastname'],\
            'Guest lastname not matching Expected:%s Got: %s'%(form_data['lastname'],guest['lastname'])

    assert site1.id == guest['site_id'], "Giest site_id not matching expected:%s got:%s"%(site1.id,guest['site_id'])

    guest_track =  Guesttrack.query.first()
    assert GUESTRACK_VOUCHER_AUTH == guest_track.state, "Guesttrack state is not GUESTRACK_VOUCHER_AUTH"
    assert voucher.time_available() == guest_track.duration, "Guesttrack duration is not expected "
Exemple #42
0
 def setUp(self):
     self.db_fd, current_app.config['DATABASE'] = tempfile.mkstemp()
     current_app.config['TESTING'] = True
     self.client = current_app.test_client()
     #db = _get_db()
     #db.connection.drop_database(current_app.config['MONGODB_SETTINGS']['DB'])
     loadFixtures()
Exemple #43
0
def test_email_login3(fake_facebook,session,guest_logged):
    '''Test email_login view with guest enetering data

    '''
    site1           = Wifisite.query.filter_by(unifi_id='site1').first() 
    guest_track     = Guesttrack.query.first()
    guest_device   = Device.query.first()
    url = url_for('guest.email_login',track_id=guest_track.track_id)   

    firstname   = fake.first_name() 
    lastname    = fake.last_name() 
    email       = fake.email()
    form_data = {'firstname':firstname,'email':email,'lastname':lastname}


    url = url_for('guest.email_login',track_id=guest_track.track_id)
    result = current_app.test_client().post(url,follow_redirects=False,data=form_data)
    auth_url = url_for('guest.authorize_guest',track_id=guest_track.track_id, _external=True)
    assert auth_url == result.location, "UE gets redirected to :%s instead of expected :%s"%(result.location,auth_url)  
    #check if guest is created
    guest = Guest.query.first().to_dict()
    assert form_data['firstname'] == guest['firstname'],\
            'Guest firstname not matching expected:%s getting:%s'%(form_data['firstname'],guest['firstname'])
    assert form_data['lastname'] == guest['lastname'],\
            'Guest lastname not matching Expected:%s Got: %s'%(form_data['lastname'],guest['lastname'])
    assert form_data['email'] == guest['email'],\
            'Guest email not matching Expected:%s Got: %s'%(form_data['email'],guest['email'])

    assert site1.id == guest['site_id'], "Giest site_id not matching expected:%s got:%s"%(site1.id,guest['site_id'])

    guest_track =  Guesttrack.query.first()
    assert GUESTRACK_EMAIL_AUTH == guest_track.state, "Guesttrack state is not GUESTRACK_EMAIL_AUTH"
Exemple #44
0
def oembed(url):
    path = urlparse(url).path + "?format=json"
    with app.test_client() as c:
        rv = c.get(path)
        try:
            article = loads(rv.data)
        except ValueError:
            print url
            print path
            raise
    if request.args.get("format") == "html":
        return html(article)
    return {
        "success": True,
        "type": "rich",
        "version": "1.0",
        "provider_name": "Venturelog",
        "provider_url": "http://www.venturelog.io",
        "title": article['headline'],
        "author_name": "Brad Smith",
        "author_url": "http://www.venturelog.io",
        "height": "300",
        "width": "800",
        "thumbnail_width": "200",
        "thumbnail_height": str(int(200 * float(3)/4)),
        "thumbnail_url": thumbUrl(article['thumbnail']),
        "html": html(article)
    }
Exemple #45
0
def _make_context():
    return dict(
        db=OrmDb(),
        repos=repositories,
        tt=testtools,
        client=current_app.test_client()
    )
Exemple #46
0
def app():
    # doing tests on remote "not-sqlite" DB, create app wit TestConfig as argument
    app = create_app(TestConfig)
    with app.app_context():
        current_app.test_client()

        db.create_all()
        user1 = User(username="******", email="*****@*****.**")
        user2 = User(username="******", email="*****@*****.**")
        user3 = User(username="******", email="*****@*****.**")
        user3.set_password("micha")
        user3.encrypt_site_password("MaRaKuJa1")
        db.session.add_all([user1, user2, user3])
        db.session.commit()

        yield current_app
Exemple #47
0
def admin1_logged(request):
    '''fixture used to create a logged in instance of test_client 

        based on multiple examples like http://librelist.com/browser/flask/2012/7/1/giving-context-to-test-client/#dfb70ea7e1b300da59d9d0ba6a2c0d52
    '''
    username = '******'
    password = '******'

    original_client = current_app.test_client
    logged_client = current_app.test_client()

    login_resp = logged_client.post(url_for('security.login'),
                                    data={
                                        'email': username,
                                        'password': password
                                    },
                                    follow_redirects=True)
    assert 'Bad username or password' not in login_resp.data, 'Login Failed '

    current_app.test_client = logged_client  #temperarly replace test_client with instance of logged in client

    def teardown():
        current_app.test_client = original_client  #change back client to original version

    request.addfinalizer(teardown)
    return logged_client
Exemple #48
0
    def dispatch(
        self,
        path: str,
        method: str,
        data: dict = None,
        files: Mapping[str, BinaryIO] = None,
        json: dict = None,
        params: dict = None,
        request=None,
        tenant=True,
    ) -> Response:
        if request:
            assert not json
            assert not data
            assert not files
            data = request.data
            files = request.files
            json = None
            params = request.args

        if tenant is True:
            tenant = auth.get_current_tenant()

        if json:
            assert not data
            data = dumps(json)
            content_type = 'application/json'
        elif files:
            if not data:
                data = {}
            for key, value in request.form.items():
                data[key] = value
            for key, value in files.items():
                data[key] = value
            content_type = 'multipart/form-data'
        else:
            content_type = None

        with current_app.test_client() as client:
            response = client.open(path='/api/{}'.format(path.lstrip('/')),
                                   query_string=params,
                                   method=method,
                                   content_type=content_type,
                                   data=data,
                                   environ_overrides={
                                       'zeus.tenant': tenant,
                                   })
        if not (200 <= response.status_code < 300):
            raise ApiError(
                text=response.get_data(as_text=True),
                code=response.status_code,
            )
        if response.headers['Content-Type'] != 'application/json':
            raise ApiError(
                text='Request returned invalid content type: {}'.format(
                    response.headers['Content-Type']),
                code=response.status_code,
            )
        return response
def test_sync_rate_limit(alter_xmlrpc):
    alter_xmlrpc([dict(name='packageC', summary='Test package.', version='3.0.0'), ])

    assert '302 FOUND' == current_app.test_client().get('/pypi/sync').status

    expected = [('packageB', 'Test package.', '3.0.0'), ]
    actual = db.session.query(Package.name, Package.summary, Package.latest_version).all()
    assert expected == actual
def test_pretty_page():
    with current_app.test_client() as c:
        c.application.config['PROPAGATE_EXCEPTIONS'] = False
        request = c.get('/examples/exception/')
        c.application.config['PROPAGATE_EXCEPTIONS'] = True

    assert '500 INTERNAL SERVER ERROR' == request.status
    assert '<title>PyPI Portal - HTTP 500</title>' in request.data
def test_sync_empty(alter_xmlrpc):
    alter_xmlrpc(set())
    redis.delete(POLL_SIMPLE_THROTTLE)
    Package.query.delete()
    db.session.commit()

    assert '302 FOUND' == current_app.test_client().get('/pypi/sync').status
    assert [] == db.session.query(Package.name, Package.summary, Package.latest_version).all()
    def setUp(self):
        self.app = current_app.test_client()
        self.requestHelper = RequestsHelper(current_app.test_client(), 'api/service_orders')

        patient = Patient(name='patient xyz from service order api test ', mobileNumber='54687643756')
        service = Service(name='service xyz XXX', price=450)

        db.session.add(patient)
        db.session.add(service)

        serviceOrder = ServiceOrder(patient=patient, service=service, numberOfSessions=12)
        serviceOrder2 = ServiceOrder(patient=patient, service=service, numberOfSessions=4)
        serviceOrder3 = ServiceOrder(patient=patient, service=service, numberOfSessions=8)
        db.session.add(serviceOrder)
        db.session.add(serviceOrder2)
        db.session.add(serviceOrder3)
        db.session.commit()
Exemple #53
0
 def test_update_settings_fails_when_bad_content_type(self,
                                                      av_get_settings_document,
                                                      av_update_generic):
     av_get_settings_document.return_value = {'starfish': 'patrick'}
     with current_app.test_client() as c:
         resp_object = c.put('/api/v1/admin/settings',content_type='spongey')
         assert resp_object.data == '"no valid settings parameters supplied"'
         assert resp_object.status_code == 409
Exemple #54
0
def test_wifisite_api2(session):
    ''' Test Wifisite invalid API calls

    '''
    #Invalid API requests   
    assert '404 NOT FOUND' == current_app.test_client().get('/client/site/api/20').status
    assert '404 NOT FOUND' == current_app.test_client().post('/client/site/api/20').status
    assert '404 NOT FOUND' == current_app.test_client().delete('/client/site/api/20').status
    assert '405 METHOD NOT ALLOWED' == current_app.test_client().delete('/client/site/api/').status

    #test getting all stored sites
    result = current_app.test_client().get('/client/site/api/').json
    assert 1 == result['status']
    assert 3 == len(result['data'])
    assert site1 == result['data'][0]
    assert site2 == result['data'][1]
    assert site3 == result['data'][2]
    def run(self, result=None):
        # initialize global test configuration here...
        global_test_config = {}
        global_test_config.update(self.custom_test_config or {})

        with provision_database(global_test_config):
            self.client = current_app.test_client()
            super().run(result)
Exemple #56
0
def start(type):
    """
    Start new node

    :param type: str - rs | aws[ | regular?] - type of registered node
    :return:
    """

    nodes = []
    # rs | aws
    if type == 'rs':

        prop_parent = Property.query.filter_by(name='rs').all()
        # props_by_user = Property.query.filter(Property.users.contains(current_user)).limit(100).all()
        print prop_parent, current_user.props

        # for role in current_user.roles:
        #     print role.id
        #     prop_by_roles = Property.query.filter(Property.roles.contains(role)).all()
        #     for prop in prop_by_roles:
        #         print prop

        props = {}

        for p in current_user.props:
            print p.id
            props_filter = ['ssh_keys', 'rs_credentials']
            for name in props_filter:
                if p.parent and p.parent.name == name:
                    if not props.get(name):
                        props[name] = {}
                    props[name][p.name] = p.value

        print props['rs_credentials']
        # with current_app.test_request_context('/'):
            # print current_app.user_datastore
            # u = current_user
        api = RsVm.instance(dict=props['rs_credentials'])
        api.enable_cache_handler(auth_cache_handler)

        print current_app.test_client()
        print api._get_config()
        nodes = api.list_servers().get('servers')

    return dict(nodes=nodes, exec_url="/exec/123"), 200
Exemple #57
0
 def test_get_group_fails_when_group_not_found(self,
                                               av_get_group_document,
                                               av_get_group_document_with_child_links,
                                               av_get_group_document_with_child_objects):
     av_get_group_document.side_effect = NotFoundError('no group document found for 4422')
     resp_object = current_app.test_client().get('/api/v1/admin/groups/4422')
     av_get_group_document.assert_called_once_with('4422')
     assert resp_object.status_code == 404
     assert resp_object.data == '"no group document found for 4422"'
Exemple #58
0
    def setUp(self):
        super(FrontendTestCase, self).setUp()

        # Push a request context
        self.req_ctx = app.test_request_context()
        self.req_ctx.push()

        # Create our test client
        self.client = app.test_client()
Exemple #59
0
    def setUp(self):
        # mock out mail
        mail_context = mail.record_messages()
        self.outbox = mail_context.__enter__()
        self.addCleanup(lambda: mail_context.__exit__(None, None, None))

        self.client = app.test_client()

        super(TestCase, self).setUp()