Python TestApp.delete方法代码示例

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
def test_delete_pages(town_app):
    client = Client(town_app)

    root_url = client.get('/').pyquery('.top-bar-section a').attr('href')

    login_page = client.get('/login?to={}'.format(root_url))
    login_page.form['email'] = '[email protected]'
    login_page.form['password'] = 'hunter2'

    root_page = login_page.form.submit().follow()
    new_page = root_page.click('Thema')

    new_page.form['title'] = "Living in Govikon is Swell"
    new_page.form['text'] = (
        "## Living in Govikon is Really Great\n"
        "*Experts say it's the fact that Govikon does not really exist.*"
    )
    page = new_page.form.submit().follow()
    delete_link = page.pyquery('a[ic-delete-from]')[0].attrib['ic-delete-from']

    result = client.delete(delete_link.split('?')[0], expect_errors=True)
    assert result.status_code == 403

    assert client.delete(delete_link).status_code == 200
    assert client.delete(delete_link, expect_errors=True).status_code == 404

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
class TestService(TestCase):

    def setUp(self):
        self.config = testing.setUp()
        self.config.include("cornice")
        self.config.scan("cornice.tests.test_service")
        self.config.scan("cornice.tests.test_pyramidhook")
        self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))

    def tearDown(self):
        testing.tearDown()

    def test_404(self):
        # a get on a resource that explicitely return a 404 should return
        # 404
        self.app.get("/service", status=404)

    def test_405(self):
        # calling a unknown verb on an existing resource should return a 405
        self.app.post("/service", status=405)

    def test_acl_support(self):
        self.app.delete('/service')

    def test_class_support(self):
        self.app.get('/fresh-air', status=400)
        resp = self.app.get('/fresh-air', headers={'X-Temperature': '50'})
        self.assertEquals(resp.body, 'fresh air')

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
def test_people_view(town_app):
    client = Client(town_app)

    login_page = client.get('/login')
    login_page.form.set('email', '[email protected]')
    login_page.form.set('password', 'hunter2')
    login_page.form.submit()

    people = client.get('/personen')
    assert 'noch keine Personen' in people

    new_person = people.click('Person')
    new_person.form['first_name'] = 'Flash'
    new_person.form['last_name'] = 'Gordon'
    person = new_person.form.submit().follow()

    assert 'Flash Gordon' in person

    people = client.get('/personen')

    assert 'Flash Gordon' in people

    edit_person = person.click('Bearbeiten')
    edit_person.form['first_name'] = 'Merciless'
    edit_person.form['last_name'] = 'Ming'
    person = edit_person.form.submit().follow()

    assert 'Merciless Ming' in person

    client.delete(person.request.url)

    people = client.get('/personen')
    assert 'noch keine Personen' in people

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
class Detalle(TestCase):
    """
    NOTA: Sobre la validación de datos, testar directamente nuestra pequeña clase 
    """

    @classmethod
    def setUpClass(self):

        # Cargamos los datos
        entidad = cargar_datos('usuario')[1]
        self.uid = entidad['uid']
        self.datos = {'corpus': entidad}

        # Trabajamos en obtener un token
        self.token = cargar_credenciales()
        
        # Creamos nuestro objeto para pruebas
        from justine import main
        from webtest import TestApp

        app = main({})
        self.testapp = TestApp(app)

        res = self.testapp.post_json('/usuarios', status=201, params=self.datos, headers=self.token)

    @classmethod
    def tearDownClass(self):
        res = self.testapp.head('/usuarios/' + self.uid, status="*", headers=self.token)
        if res.status_int == 200:
            self.testapp.delete('/usuarios/' + self.uid, status=200, headers=self.token)

    def test_detalle_usuario(self):
        res = self.testapp.get('/usuarios/' + self.uid, status=200, headers=self.token) 
        respuesta = res.json_body['mensaje'][0]['givenName']
        datos = self.datos['corpus']['givenName']
        
        self.assertEqual(respuesta, datos)

    def test_detalle_claves(self):
        claves = ['dn', 'givenName', 'cn']

        res = self.testapp.get('/usuarios/' + self.uid, params={'claves': ','.join(claves)}, headers=self.token)
        respuesta = res.json_body['mensaje'][0].keys()
        self.assertListEqual(respuesta, claves)

    def test_detalle_claves_noexistentes(self):
        claves = ['dn', 'givenName', 'cn', 'noexistente']

        res = self.testapp.get('/usuarios/' + self.uid, params={'claves': ','.join(claves)}, headers=self.token)
        respuesta = res.json_body['mensaje'][0].keys()
        del claves[claves.index('noexistente')]
        
        self.assertListEqual(respuesta, claves)
    
    def test_detalle_noexistente(self):
        uid = 'fitzcarraldo'
        self.testapp.get('/usuarios/' + uid, status=404, headers=self.token)
        
    def test_detalle_unauth(self):
        self.testapp.post_json('/usuarios' + self.uid, status=404)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
    def test_custom_with_trailing_slash(self):

        class CustomController(RestController):

            _custom_actions = {
                'detail': ['GET'],
                'create': ['POST'],
                'update': ['PUT'],
                'remove': ['DELETE'],
            }

            @expose()
            def detail(self):
                return 'DETAIL'

            @expose()
            def create(self):
                return 'CREATE'

            @expose()
            def update(self, id):
                return id

            @expose()
            def remove(self, id):
                return id

        app = TestApp(make_app(CustomController()))

        r = app.get('/detail')
        assert r.status_int == 200
        assert r.body == b_('DETAIL')

        r = app.get('/detail/')
        assert r.status_int == 200
        assert r.body == b_('DETAIL')

        r = app.post('/create')
        assert r.status_int == 200
        assert r.body == b_('CREATE')

        r = app.post('/create/')
        assert r.status_int == 200
        assert r.body == b_('CREATE')

        r = app.put('/update/123')
        assert r.status_int == 200
        assert r.body == b_('123')

        r = app.put('/update/123/')
        assert r.status_int == 200
        assert r.body == b_('123')

        r = app.delete('/remove/456')
        assert r.status_int == 200
        assert r.body == b_('456')

        r = app.delete('/remove/456/')
        assert r.status_int == 200
        assert r.body == b_('456')

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
class FunctionalTest(unittest.TestCase):
    def setUp(self):
        self.app = TestApp(application) 

    def test_index_returns_200(self):  
        response = self.app.get('/', expect_errors=True)        
        self.assertEquals("200 OK", response.status)
            
    def test_index_return_correct_mime_type(self):
        response = self.app.get('/', expect_errors=True)
        self.assertEquals(response.content_type, "text/html")
        
    def test_multiple_args_in_url(self):
        response = self.app.get('/foo/1/2', expect_errors=True)        
        response.mustcontain("Hello World of 1 and 2")

    def test_put(self):
        response = self.app.put('/', expect_errors=True)        
        self.assertEquals("200 OK", response.status)
        response.mustcontain("Hello World of Put")
        
    def test_404_handler(self):  
        response = self.app.get('/does-not-exist', expect_errors=True)        
        self.assertEquals("404 Not Found", response.status)

    def test_404_handler(self):  
        response = self.app.get('/does-not-exist', expect_errors=True)        
        self.assertEquals("404 Not Found", response.status)

    def test_HTTPResponseRedirect_handler(self):
        response = self.app.get('/bar', expect_errors=True)        
        self.assertEquals("/", response.headers['Location'])
        self.assertEquals("301 Moved Permanently", response.status)

    def test_temporaty_HTTPResponseRedirect_handler(self):
        response = self.app.delete('/bar', expect_errors=True)        
        self.assertEquals("/", response.headers['Location'])
        self.assertEquals("302 Found", response.status)

    def test_unregistered_post_request(self):
        response = self.app.post('/', expect_errors=True)        
        self.assertEquals("405 Method Not Allowed", response.status)

    def test_unregistered_delete_request(self):
        response = self.app.delete('/', expect_errors=True)        
        self.assertEquals("405 Method Not Allowed", response.status)

    def test_unregistered_put_request(self):
        response = self.app.put('/bar', expect_errors=True)        
        self.assertEquals("405 Method Not Allowed", response.status)

    def test_query_string(self):  
        response = self.app.get('/?test=test', expect_errors=True)        
        self.assertEqual("test", response.request.GET['test'])
        self.assertEquals("200 OK", response.status)

    def test_addition_of_method_to_request(self):  
        response = self.app.get('/', expect_errors=True)        
        self.assertEqual("GET", response.request.method)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
class DwarfTestCase(utils.TestCase):

    def setUp(self):
        super(DwarfTestCase, self).setUp()
        self.app = TestApp(ApiServer().app)

    # Commented out to silence pylint
    # def tearDown(self):
    #     super(DwarfTestCase, self).tearDown()

    def test_list_flavors(self):
        resp = self.app.get('/compute/v2.0/flavors', status=200)
        self.assertEqual(json.loads(resp.body),
                         list_flavors_resp([flavor1, flavor2, flavor3],
                                           details=False))

    def test_list_flavors_detail(self):
        resp = self.app.get('/compute/v2.0/flavors/detail', status=200)
        self.assertEqual(json.loads(resp.body),
                         list_flavors_resp([flavor1, flavor2, flavor3],
                                           details=True))

    def test_show_flavor(self):
        resp = self.app.get('/compute/v2.0/flavors/%s' % flavor1['id'],
                            status=200)
        self.assertEqual(json.loads(resp.body), show_flavor_resp(flavor1))

    def test_delete_flavor(self):
        # Delete flavor[0]
        resp = self.app.delete('/compute/v2.0/flavors/%s' % flavor1['id'],
                               status=200)
        self.assertEqual(resp.body, '')

        # Check the resulting list of flavors
        resp = self.app.get('/compute/v2.0/flavors', status=200)
        self.assertEqual(json.loads(resp.body),
                         list_flavors_resp([flavor2, flavor3], details=False))

    def test_create_flavor(self):
        # Delete flavor[0]
        self.app.delete('/compute/v2.0/flavors/%s' % flavor1['id'], status=200)

        # Check the resulting list of flavors
        resp = self.app.get('/compute/v2.0/flavors', status=200)
        self.assertEqual(json.loads(resp.body),
                         list_flavors_resp([flavor2, flavor3], details=False))

        # (Re-)create flavor[0]
        resp = self.app.post('/compute/v2.0/flavors',
                             params=json.dumps(create_flavor_req(flavor1)),
                             status=200)
        self.assertEqual(json.loads(resp.body), create_flavor_resp(flavor1))

        # Check the resulting list of flavors
        resp = self.app.get('/compute/v2.0/flavors', status=200)
        self.assertEqual(json.loads(resp.body),
                         list_flavors_resp([flavor2, flavor3, flavor1],
                                           details=False))

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
class Creacion(TestCase):
    """
    NOTA: Sobre la validación de datos, testar directamente nuestra pequeña clase 
    """

    @classmethod
    def setUp(self):

        # Cargamos los datos
        entidad = cargar_datos('usuario')[0]
        self.uid = entidad['uid']
        self.datos = {'corpus': entidad}

        # Trabajamos en obtener un token
        self.token = cargar_credenciales()
        
        # Creamos nuestro objeto para pruebas
        from justine import main
        from webtest import TestApp

        app = main({})
        self.testapp = TestApp(app)

    @classmethod
    def tearDownClass(self):
        res = self.testapp.head('/usuarios/' + self.uid, status="*", headers=self.token)
        if res.status_int == 200:
            self.testapp.delete('/usuarios/' + self.uid, status=200, headers=self.token)

    def test_creacion(self):
        res = self.testapp.post_json('/usuarios', status=201, params=self.datos, headers=self.token)
        respuesta = res.location
        self.assertEqual(respuesta, 'http://localhost/usuarios/%s' % self.uid)

    def test_creacion_no_json(self):
        datos = "Mínimo esfuerzo para máximo daño"
        self.testapp.post_json('/usuarios', status=400, params=datos, headers=self.token)

    def test_creacion_corpus_faltante(self):
        datos = {'cuerpo': self.datos['corpus'].copy()}
        
        self.testapp.post_json('/usuarios', status=400, params=datos, headers=self.token)

    def test_creacion_usuario_existente(self):
        self.testapp.post_json('/usuarios', status=409, params=self.datos, headers=self.token)
   
    def test_creacion_usuario_datos_inconsistente(self):
        datos = self.datos.copy()
        datos['corpus']['grupo'] = "0"
        datos['corpus']['uid'] = "nuevoUsuario"
        
        self.testapp.post_json('/usuarios', status=400, params=datos, headers=self.token)

    def test_usuarios_creacion_unauth(self):
        self.testapp.post_json('/usuarios', status=403, params=self.datos)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
    def test_clienttester(self):

        app = TestApp(ClientTesterMiddleware(SomeApp()))

        # that calls the app
        app.get('/bleh', status=200)

        # let's ask for a 503 and then a 400
        app.post('/__testing__', params=_d({'status': 503}))
        app.post('/__testing__', params=_d({'status': 400}))

        app.get('/buh', status=503)
        app.get('/buh', status=400)

        # back to normal
        app.get('/buh', status=200)

        # let's ask for two 503s
        app.post('/__testing__',
                 params=_d({'status': 503, 'repeat': 2}))

        app.get('/buh', status=503)
        app.get('/buh', status=503)
        app.get('/buh', status=200)

        # some headers and body now
        app.post('/__testing__',
                params=_d({'status': 503, 'body': 'oy',
                           'headers': {'foo': '1'}}))

        res = app.get('/buh', status=503)
        self.assertEqual(res.body, 'oy')
        self.assertEqual(res.headers['foo'], '1')

        # repeat stuff indefinitely
        app.post('/__testing__',
                params=_d({'status': 503, 'body': 'oy',
                           'headers': {'foo': '1'},
                           'repeat': -1}))

        for i in range(20):
            app.get('/buh', status=503)

        # let's wipe out the pile
        app.delete('/__testing__')
        app.get('/buh', status=200)

        # a bit of timing now
        app.post('/__testing__',
                params=_d({'status': 503, 'delay': .5}))
        now = time.time()
        app.get('/buh', status=503)
        then = time.time()
        self.assertTrue(then - now >= .5)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
    def test_simple_nested_rest(self):

        class BarController(RestController):

            @expose()
            def post(self):
                return "BAR-POST"

            @expose()
            def delete(self, id_):
                return "BAR-%s" % id_

            @expose()
            def post(self):
                return "BAR-POST"

            @expose()
            def delete(self, id_):
                return "BAR-%s" % id_

        class FooController(RestController):

            bar = BarController()

            @expose()
            def post(self):
                return "FOO-POST"

            @expose()
            def delete(self, id_):
                return "FOO-%s" % id_

        class RootController(object):
            foo = FooController()

        # create the app
        app = TestApp(make_app(RootController()))

        r = app.post('/foo')
        assert r.status_int == 200
        assert r.body == "FOO-POST"

        r = app.delete('/foo/1')
        assert r.status_int == 200
        assert r.body == "FOO-1"

        r = app.post('/foo/bar')
        assert r.status_int == 200
        assert r.body == "BAR-POST"

        r = app.delete('/foo/bar/2')
        assert r.status_int == 200
        assert r.body == "BAR-2"

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
    def test_singular_resource(self, *a):
        View = get_test_view_class()
        config = _create_config()
        root = config.get_root_resource()
        root.add('thing', view=View)
        grandpa = root.add('grandpa', 'grandpas', view=View)
        wife = grandpa.add('wife', view=View, renderer='string')
        wife.add('child', 'children', view=View)

        config.begin()
        app = TestApp(config.make_wsgi_app())

        self.assertEqual(
            '/grandpas/1/wife',
            route_path('grandpa:wife', testing.DummyRequest(), grandpa_id=1)
        )

        self.assertEqual(
            '/grandpas/1',
            route_path('grandpa', testing.DummyRequest(), id=1)
        )

        self.assertEqual(
            '/grandpas/1/wife/children/2',
            route_path('grandpa_wife:child', testing.DummyRequest(),
                       grandpa_id=1, id=2)
        )

        self.assertEqual(app.put('/grandpas').body, six.b('update_many'))
        self.assertEqual(app.head('/grandpas').body, six.b(''))
        self.assertEqual(app.options('/grandpas').body, six.b(''))

        self.assertEqual(app.delete('/grandpas/1').body, six.b('delete'))
        self.assertEqual(app.head('/grandpas/1').body, six.b(''))
        self.assertEqual(app.options('/grandpas/1').body, six.b(''))

        self.assertEqual(app.put('/thing').body, six.b('replace'))
        self.assertEqual(app.patch('/thing').body, six.b('update'))
        self.assertEqual(app.delete('/thing').body, six.b('delete'))
        self.assertEqual(app.head('/thing').body, six.b(''))
        self.assertEqual(app.options('/thing').body, six.b(''))

        self.assertEqual(app.put('/grandpas/1/wife').body, six.b('replace'))
        self.assertEqual(app.patch('/grandpas/1/wife').body, six.b('update'))
        self.assertEqual(app.delete('/grandpas/1/wife').body, six.b('delete'))
        self.assertEqual(app.head('/grandpas/1/wife').body, six.b(''))
        self.assertEqual(app.options('/grandpas/1/wife').body, six.b(''))

        self.assertEqual(six.b('show'), app.get('/grandpas/1').body)
        self.assertEqual(six.b('show'), app.get('/grandpas/1/wife').body)
        self.assertEqual(
            six.b('show'), app.get('/grandpas/1/wife/children/1').body)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
def test_delete_builtin_form(town_app):
    client = Client(town_app)
    builtin_form = '/formular/wohnsitzbestaetigung'

    response = client.delete(builtin_form, expect_errors=True)
    assert response.status_code == 403

    login_page = client.get('/login')
    login_page.form.set('email', '[email protected]')
    login_page.form.set('password', 'hunter2')
    login_page.form.submit()

    response = client.delete(builtin_form, expect_errors=True)
    assert response.status_code == 403

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
def test_delete_custom_form(town_app):
    client = Client(town_app)

    login_page = client.get('/login')
    login_page.form.set('email', '[email protected]')
    login_page.form.set('password', 'hunter2')
    login_page.form.submit()

    form_page = client.get('/formulare/neu')
    form_page.form['title'] = "My Form"
    form_page.form['definition'] = "e-mail * = @@@"
    form_page = form_page.form.submit().follow()

    client.delete(
        form_page.pyquery('a.delete-link')[0].attrib['ic-delete-from'])

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
class TestShield(unittest.TestCase):

    def setUp(self):
        self.app = TestApp(application)

    def test_shields(self):
        response = self.app.post_json('/api/_login', {"username": "felipe", "password": '123'})
        self.assertEqual(200, response.status_int)

        response = self.app.get('/api/person/')
        self.assertEqual(200, response.status_int)

        self.app = TestApp(application)
        response = self.app.get('/api/person', expect_errors=True)
        self.assertEquals(401, response.status_int)

        self.app = TestApp(application)
        response = self.app.post('/api/person/', expect_errors=True)
        self.assertIsNot(401, response.status_int)

        self.app = TestApp(application)
        response = self.app.put('/api/person/', expect_errors=True)
        self.assertIsNot(404, response.status_int)

        self.app = TestApp(application)
        response = self.app.delete('/api/person/', expect_errors=True)
        self.assertIsNot(404, response.status_int)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import delete [as 别名]
def test_delete_supercar():
    supercars[1] = {'engine': '1'}
    app = TestApp(default_app())

    resp = app.delete('/supercars/1')
    assert_equal(resp.status, '200 OK')
    app.reset()