Ejemplo n.º 1
0
def test_simple_path_two_steps():
    config = setup()

    class app(morepath.App):
        testing_config = config

    class Model(object):
        def __init__(self):
            pass

    @app.path(model=Model, path='one/two')
    def get_model():
        return Model()

    @app.view(model=Model)
    def default(self, request):
        return "View"

    @app.view(model=Model, name='link')
    def link(self, request):
        return request.link(self)

    config.commit()

    c = Client(app())

    response = c.get('/one/two')
    assert response.body == b'View'

    response = c.get('/one/two/link')
    assert response.body == b'http://localhost/one/two'
Ejemplo n.º 2
0
def test_expires():
    options = {'session.validate_key':'hoobermas', 'session.type':'cookie',
               'session.cookie_expires': datetime.timedelta(days=1)}
    app = TestApp(SessionMiddleware(simple_app, **options))
    res = app.get('/')
    assert 'expires=' in res.headers.getall('Set-Cookie')[0]
    assert 'current value is: 1' in res
Ejemplo n.º 3
0
Archivo: tests.py Proyecto: Jaykul/kule
 def test_magical_methods(self):
     class MyKule(Kule):
         def get_documents_list(self):
             return {"foo": "bar"}
     kule = MyKule(database="kule_test", collections=["documents"])
     app = TestApp(kule.get_bottle_app())
     self.assertEqual(app.get("/documents").json, {"foo": "bar"})
Ejemplo n.º 4
0
def test_variable_path_parameter_required_with_default():
    config = setup()

    class app(morepath.App):
        testing_config = config

    class Model(object):
        def __init__(self, id):
            self.id = id

    @app.path(model=Model, path='', required=['id'])
    def get_model(id='b'):
        return Model(id)

    @app.view(model=Model)
    def default(self, request):
        return "View: %s" % self.id

    @app.view(model=Model, name='link')
    def link(self, request):
        return request.link(self)

    config.commit()

    c = Client(app())

    response = c.get('/?id=a')
    assert response.body == b"View: a"

    response = c.get('/', status=400)
Ejemplo n.º 5
0
class IntegrationTests(unittest.TestCase):
    def setUp(self):
        from webtest import TestApp
        from pyramid.paster import get_app
        app = get_app('development.ini')
        self.app = TestApp(app)


    def tearDown(self):
        testing.tearDown()


    def test_login_view(self):
        self.app.authorization = ('Basic', ('user', 'password'))
        response = self.app.get('/login')
        self.assertEqual(response.status_int, 200)


    def test_logout_view(self):
        # run login to start session
        self.app.authorization = ('Basic', ('user', 'password'))
        self.app.get('/login')
        response = self.app.get('/logout')
        self.assertEqual(response.status_int, 200)


    def test_logout_not_loggedin(self):
        # expect 403 when trying to log out again
        from pyramid.httpexceptions import HTTPForbidden
        response = self.app.get('/logout', expect_errors=True)
        self.assertEqual(response.status_int, 401)
Ejemplo n.º 6
0
def _RunCompleterCommand_GoTo_all_Clang(filename, command, test):
  contents = open( PathToTestFile( filename ) ).read()
  app = TestApp( handlers.app )
  common_request = {
    'completer_target'  : 'filetype_default',
    'command_arguments' : command,
    'compilation_flags' : ['-x',
                           'c++',
                           '-std=c++11'],
    'line_num'          : 10,
    'column_num'        : 3,
    'contents'          : contents,
    'filetype'          : 'cpp'
  }
  common_response = {
    'filepath'  : os.path.abspath( '/foo' ),
  }

  request = common_request
  request.update({
      'line_num'  : test['request'][0],
      'column_num': test['request'][1],
  })
  response = common_response
  response.update({
      'line_num'  : test['response'][0],
      'column_num': test['response'][1],
  })

  goto_data = BuildRequest( **request )

  eq_( response,
       app.post_json( '/run_completer_command', goto_data ).json )
Ejemplo n.º 7
0
 def test_enforce_https_wrong(self):
     config = copy.deepcopy(SHARED_DEFAULTS)
     config["enforce_https"] = True
     application = RoutingApplication(config)
     app = TestApp(application, extra_environ={"REMOTE_ADDR": "127.0.0.1"})
     app.get("/", status=406)
     app.post("/connect", status=406)
Ejemplo n.º 8
0
def RunCompleterCommand_GetType_TypescriptCompleter_test():
  app = TestApp( handlers.app )

  filepath = PathToTestFile( 'test.ts' )
  contents = open( filepath ).read()

  event_data = BuildRequest( filepath = filepath,
                             filetype = 'typescript',
                             contents = contents,
                             event_name = 'BufferVisit' )

  app.post_json( '/event_notification', event_data )

  gettype_data = BuildRequest( completer_target = 'filetype_default',
                               command_arguments = ['GetType'],
                               line_num = 12,
                               column_num = 1,
                               contents = contents,
                               filetype = 'typescript',
                               filepath = filepath )

  eq_( {
         'message': 'var foo: Foo'
       },
       app.post_json( '/run_completer_command', gettype_data ).json )
Ejemplo n.º 9
0
def _RunCompleterCommand_Message_Clang(filename, test, command):
  contents = open( PathToTestFile( filename ) ).read()
  app = TestApp( handlers.app )

  common_args = {
    'completer_target'  : 'filetype_default',
    'command_arguments' : command,
    'compilation_flags' : ['-x',
                           'c++',
                           '-std=c++11'],
    'line_num'          : 10,
    'column_num'        : 3,
    'contents'          : contents,
    'filetype'          : 'cpp'
  }

  args = test[0]
  expected = test[1];

  request = common_args
  request.update( args )

  request_data = BuildRequest( **request )

  eq_( {'message': expected},
        app.post_json( '/run_completer_command', request_data ).json )
Ejemplo n.º 10
0
def GetCompletions_ClangCompleter_WorksWithExplicitFlags_test():
  app = TestApp( handlers.app )
  contents = """
struct Foo {
  int x;
  int y;
  char c;
};

int main()
{
  Foo foo;
  foo.
}
"""

  # 0-based line and column!
  completion_data = BuildRequest( filepath = '/foo.cpp',
                                  filetype = 'cpp',
                                  contents = contents,
                                  line_num = 10,
                                  column_num = 6,
                                  start_column = 6,
                                  compilation_flags = ['-x', 'c++'] )

  results = app.post_json( '/completions', completion_data ).json
  assert_that( results, has_items( CompletionEntryMatcher( 'c' ),
                                   CompletionEntryMatcher( 'x' ),
                                   CompletionEntryMatcher( 'y' ) ) )
Ejemplo n.º 11
0
def GetCompletions_ClangCompleter_ForceSemantic_OnlyFileteredCompletions_test():
  app = TestApp( handlers.app )
  contents = """
int main()
{
  int foobar;
  int floozar;
  int gooboo;
  int bleble;

  fooar
}
"""

  # 0-based line and column!
  completion_data = BuildRequest( filepath = '/foo.cpp',
                                  filetype = 'cpp',
                                  force_semantic = True,
                                  contents = contents,
                                  line_num = 8,
                                  column_num = 7,
                                  start_column = 7,
                                  query = 'fooar',
                                  compilation_flags = ['-x', 'c++'] )

  results = app.post_json( '/completions', completion_data ).json
  assert_that( results,
               contains_inanyorder( CompletionEntryMatcher( 'foobar' ),
                                    CompletionEntryMatcher( 'floozar' ) ) )
Ejemplo n.º 12
0
class TestResource(unittest.TestCase):
    def setUp(self):
        from pyramid.renderers import JSONP

        self.config = testing.setUp()
        self.config.add_renderer("jsonp", JSONP(param_name="callback"))
        self.config.include("cornice")
        self.config.scan("cornice.tests.test_resource")
        self.app = TestApp(CatchErrors(self.config.make_wsgi_app()))

    def tearDown(self):
        testing.tearDown()

    def test_basic_resource(self):

        self.assertEquals(self.app.get("/users").json, {"status": "ok", "result": {"users": [1, 2]}})

        self.assertEquals(self.app.get("/users/1").json, {"status": "ok", "result": {"name": "gawel"}})
        resp = self.app.get("/users/1?callback=test")
        self.assertEquals(resp.body, 'test({"status": "ok", "result": {"name": "gawel"}})', resp.body)

    def test_accept_headers(self):
        # the accept headers should work even in case they're specified in a
        # resource method
        self.assertEquals(
            self.app.post("/users", headers={"Accept": "text/json"}, params=json.dumps({"test": "yeah"})).json,
            {"status": "ok", "result": {"test": "yeah"}},
        )
Ejemplo n.º 13
0
def test_extra_predicates():
    config = setup()
    app = App(testing_config=config)

    @app.path(path='{id}')
    class Model(object):
        def __init__(self, id):
            self.id = id

    @app.view(model=Model, name='foo', id='a')
    def get_a(self, request):
        return 'a'

    @app.view(model=Model, name='foo', id='b')
    def get_b(self, request):
        return 'b'

    @app.predicate(name='id', order=2, default='')
    def get_id(self, request):
        return self.id
    config.commit()

    c = Client(app)

    response = c.get('/a/foo')
    assert response.body == 'a'
    response = c.get('/b/foo')
    assert response.body == 'b'
Ejemplo n.º 14
0
class ImperativeIncludeConfigurationTest(unittest.TestCase):
    def setUp(self):
        from pyramid.config import Configurator
        config = Configurator()
        from pyramid.tests.pkgs.includeapp1.root import configure
        configure(config)
        app = config.make_wsgi_app()
        from webtest import TestApp
        self.testapp = TestApp(app)
        self.config = config

    def tearDown(self):
        self.config.end()

    def test_root(self):
        res = self.testapp.get('/', status=200)
        self.assertTrue(b'root' in res.body)

    def test_two(self):
        res = self.testapp.get('/two', status=200)
        self.assertTrue(b'two' in res.body)

    def test_three(self):
        res = self.testapp.get('/three', status=200)
        self.assertTrue(b'three' in res.body)
Ejemplo n.º 15
0
def test_create_hosted_zone_xml():
    app = TestApp(api.api)
    request = open('createhostedzone.xml', 'r').read()
    response = app.post('/hostedzone', request)
    #reply = open('createhostedzone_response.xml', 'r').read()
    assert response.status == '201 Created'
    print response.body
Ejemplo n.º 16
0
    def test_post_task_invalid():
        test_app = TestApp(app)

        assert test_app.post_json('/task', expect_errors=True).status_int == 400

        assert test_app.post_json('/task', {
            'task_id': 'de305d54-75b4-431b-adb2-eb6b9e546013',
            'test_id': 'de305d54-75b4-431b-adb2-eb6b9e546013',
            'task_type': 'wait',
            'task_version': 'invalid_version',
            'task_data': {
                'wait_time': 3600
            }
        }, expect_errors=True).status_int == 400

        assert test_app.post_json('/task', {
            'task_id': 'de305d54-75b4-431b-adb2-eb6b9e546013_not_valid',
            'test_id': 'de305d54-75b4-431b-adb2-eb6b9e546013',
            'task_type': 'wait',
            'task_version': 1,
            'task_data': {
                'wait_time': 3600
            }
        }, expect_errors=True).status_int == 400

        assert test_app.post_json('/task', {
            'test_id': 'de305d54-75b4-431b-adb2-eb6b9e546013',
            'task_type': 'wait',
            'task_version': 1,
            'task_data': {
                'wait_time': 3600
            }
        }, expect_errors=True).status_int == 400
Ejemplo n.º 17
0
    def test_pull_task():
        test_app = TestApp(app)

        session = create_session()
        task1 = Task()
        task1.uuid = 'de305d54-75b4-431b-adb2-eb6b9e546018'
        task1.test_id = 'de305d54-75b4-431b-adb2-eb6b9e546018'
        task1.claimed = datetime.utcnow()
        task1.data = json.dumps({'wait_time': 123})
        session.add(task1)

        task2 = Task()
        task2.uuid = 'de305d54-75b4-431b-adb2-eb6b9e546019'
        task2.test_id = 'de305d54-75b4-431b-adb2-eb6b9e546019'
        task2.claimed = datetime.utcnow()
        task2.completed = datetime.utcnow()
        task2.result_data = json.dumps({'result': 'epic success'})
        session.add(task2)

        task3 = Task()
        task3.uuid = 'de305d54-75b4-431b-adb2-eb6b9e546020'
        task3.test_id = 'de305d54-75b4-431b-adb2-eb6b9e546020'
        task3.claimed = datetime.utcnow()
        task3.failed = datetime.utcnow()
        task3.error = 'unknown error'
        session.add(task3)

        session.commit()

        test_app.get('/task/de305d54-75b4-431b-adb2-eb6b9e546018')
        test_app.get('/task/de305d54-75b4-431b-adb2-eb6b9e546019')
        test_app.get('/task/de305d54-75b4-431b-adb2-eb6b9e546020')
Ejemplo n.º 18
0
    def test_get_with_var_args(self):

        class OthersController(object):

            @expose()
            def index(self, one, two, three):
                return 'NESTED: %s, %s, %s' % (one, two, three)

        class ThingsController(RestController):

            others = OthersController()

            @expose()
            def get_one(self, *args):
                return ', '.join(args)

        class RootController(object):
            things = ThingsController()

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

        # test get request
        r = app.get('/things/one/two/three')
        assert r.status_int == 200
        assert r.body == b_('one, two, three')

        # test nested get request
        r = app.get('/things/one/two/three/others/')
        assert r.status_int == 200
        assert r.body == b_('NESTED: one, two, three')
Ejemplo n.º 19
0
    def test_404_with_lookup(self):

        class LookupController(RestController):

            def __init__(self, _id):
                self._id = _id

            @expose()
            def get_all(self):
                return 'ID: %s' % self._id

        class ThingsController(RestController):

            @expose()
            def _lookup(self, _id, *remainder):
                return LookupController(_id), remainder

        class RootController(object):
            things = ThingsController()

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

        # these should 404
        for path in ('/things', '/things/'):
            r = app.get(path, expect_errors=True)
            assert r.status_int == 404

        r = app.get('/things/foo')
        assert r.status_int == 200
        assert r.body == b_('ID: foo')
Ejemplo n.º 20
0
    def test_config_hooks(self):
        class RootController(TGController):
            @expose()
            def test(self):
                return 'HI!'

        visited_hooks = []
        def before_config_hook(app):
            visited_hooks.append('before_config')
            return app
        def after_config_hook(app):
            visited_hooks.append('after_config')
            return app
        def configure_new_app_hook(app):
            assert isinstance(app, TGApp)
            visited_hooks.append('configure_new_app')

        conf = AppConfig(minimal=True, root_controller=RootController())
        conf.register_hook('before_config', before_config_hook)
        conf.register_hook('after_config', after_config_hook)
        conf.register_hook('configure_new_app', configure_new_app_hook)
        app = conf.make_wsgi_app()
        app = TestApp(app)

        assert 'HI!' in app.get('/test')
        assert 'before_config' in visited_hooks
        assert 'after_config' in visited_hooks
        assert 'configure_new_app' in visited_hooks
Ejemplo n.º 21
0
 def get(self, url, headers):
     app = TestApp(wsgi.create_app(self.minion))
     response = app.get(
         url,
         headers=[(k, ",".join(v)) for k , v in headers.canonicalized()],
     )
     return response.body
Ejemplo n.º 22
0
def RunCompleterCommand_GoTo_Clang_ZeroBasedLineAndColumn_test():
  app = TestApp( handlers.app )
  contents = """
struct Foo {
  int x;
  int y;
  char c;
};

int main()
{
  Foo foo;
  return 0;
}
"""

  goto_data = BuildRequest( completer_target = 'filetype_default',
                            command_arguments = ['GoToDefinition'],
                            compilation_flags = ['-x', 'c++'],
                            line_num = 10,
                            column_num = 3,
                            contents = contents,
                            filetype = 'cpp' )

  eq_( {
        'filepath': '/foo',
        'line_num': 2,
        'column_num': 8
      },
      app.post_json( '/run_completer_command', goto_data ).json )
Ejemplo n.º 23
0
def test_view_after_doesnt_apply_to_exception_view():
    config = setup()

    class App(morepath.App):
        testing_config = config

    class Root(object):
        pass

    class MyException(Exception):
        pass

    @App.path(model=Root, path='')
    def get_root():
        return Root()

    @App.view(model=Root)
    def view(self, request):
        @request.after
        def set_header(response):
            response.headers.add('Foo', 'FOO')
        raise MyException()

    @App.view(model=MyException)
    def exc_view(self, request):
        return "My exception"

    config.commit()

    c = Client(App())

    response = c.get('/')
    assert response.body == b'My exception'
    assert response.headers.get('Foo') is None
Ejemplo n.º 24
0
def test_path_and_url_parameter_converter():
    config = setup()

    class app(morepath.App):
        testing_config = config

    class Model(object):
        def __init__(self, id, param):
            self.id = id
            self.param = param

    from datetime import date

    @app.path(model=Model, path='/{id}', converters=dict(param=date))
    def get_model(id=0, param=None):
        return Model(id, param)

    @app.view(model=Model)
    def default(self, request):
        return "View: %s %s" % (self.id, self.param)

    @app.view(model=Model, name='link')
    def link(self, request):
        return request.link(self)

    config.commit()

    c = Client(app())

    response = c.get('/1/link')
    assert response.body == b'http://localhost/1'
Ejemplo n.º 25
0
def test_view_after_doesnt_apply_to_exception():
    config = setup()

    class App(morepath.App):
        testing_config = config

    class Root(object):
        pass

    @App.path(model=Root, path='')
    def get_root():
        return Root()

    @App.view(model=Root)
    def view(self, request):
        @request.after
        def set_header(response):
            response.headers.add('Foo', 'FOO')
        raise HTTPNotFound()

    config.commit()

    c = Client(App())

    response = c.get('/', status=404)
    assert response.headers.get('Foo') is None
Ejemplo n.º 26
0
def test_type_hints_and_converters():
    config = setup()

    class app(morepath.App):
        testing_config = config

    class Model(object):
        def __init__(self, d):
            self.d = d

    from datetime import date

    @app.path(model=Model, path='', converters=dict(d=date))
    def get_model(d):
        return Model(d)

    @app.view(model=Model)
    def default(self, request):
        return "View: %s" % self.d

    @app.view(model=Model, name='link')
    def link(self, request):
        return request.link(self)

    config.commit()

    c = Client(app())

    response = c.get('/?d=20140120')
    assert response.body == b"View: 2014-01-20"

    response = c.get('/link?d=20140120')
    assert response.body == b'http://localhost/?d=20140120'
Ejemplo n.º 27
0
def test_link_for_none_means_no_parameter():
    config = setup()

    class app(morepath.App):
        testing_config = config

    class Model(object):
        def __init__(self, id):
            self.id = id

    @app.path(model=Model, path='')
    def get_model(id):
        return Model(id)

    @app.view(model=Model)
    def default(self, request):
        return "View: %s" % self.id

    @app.view(model=Model, name='link')
    def link(self, request):
        return request.link(self)

    config.commit()

    c = Client(app())

    response = c.get('/')
    assert response.body == b"View: None"

    response = c.get('/link')
    assert response.body == b'http://localhost/'
Ejemplo n.º 28
0
    def test_simple_generic(self):
        class RootController(object):
            @expose(generic=True)
            def index(self):
                pass

            @index.when(method="POST", template="json")
            def do_post(self):
                return dict(result="POST")

            @index.when(method="GET")
            def do_get(self):
                return "GET"

        app = TestApp(Pecan(RootController()))
        r = app.get("/")
        assert r.status_int == 200
        assert r.body == "GET"

        r = app.post("/")
        assert r.status_int == 200
        assert r.body == dumps(dict(result="POST"))

        r = app.get("/do_get", status=404)
        assert r.status_int == 404
Ejemplo n.º 29
0
def test_variable_path_one_step():
    config = setup()

    class app(morepath.App):
        testing_config = config

    class Model(object):
        def __init__(self, name):
            self.name = name

    @app.path(model=Model, path='{name}')
    def get_model(name):
        return Model(name)

    @app.view(model=Model)
    def default(self, request):
        return "View: %s" % self.name

    @app.view(model=Model, name='link')
    def link(self, request):
        return request.link(self)

    config.commit()

    c = Client(app())

    response = c.get('/foo')
    assert response.body == b'View: foo'

    response = c.get('/foo/link')
    assert response.body == b'http://localhost/foo'
Ejemplo n.º 30
0
    def test_disconnect_hooks_multiple_listener(self):
        hook1_has_been_called = []
        def hook1_listener():
            hook1_has_been_called.append(True)

        hook2_has_been_called = []
        def hook2_listener():
            hook2_has_been_called.append(True)

        class RootController(TGController):
            @expose()
            def test(self):
                tg.hooks.notify('custom_hook', controller=RootController.test)
                return 'HI!'

        conf = AppConfig(minimal=True, root_controller=RootController())
        tg.hooks.register('custom_hook', hook1_listener)
        tg.hooks.register('custom_hook', hook2_listener)
        conf.package = PackageWithModel()
        app = conf.make_wsgi_app()
        app = TestApp(app)

        app.get('/test')
        app.get('/test')
        tg.hooks.disconnect('custom_hook', hook2_listener)
        app.get('/test')

        # Disconnecting an unregistered hook should do nothing.
        tg.hooks.disconnect('unregistered', hook1_listener)

        assert len(hook1_has_been_called) == 3, hook1_has_been_called
        assert len(hook2_has_been_called) == 2, hook2_has_been_called
Ejemplo n.º 31
0
    def test_SyncEntity(self):
        """Synchronizing an entity."""

        from gaesynkit import handlers
        from webtest import AppError, TestApp

        # Initialize app
        app = TestApp(handlers.app)

        # Make a request
        res = app.post(
            '/gaesynkit/rpc/',
            '{"jsonrpc":"2.0","method":"syncEntity","params":[{"kind":"Book","key":"dGVzdEBkZWZhdWx0ISFCb29rCjI=","version":0,"id":2,"properties":{"title":{"type":"string","value":"The Catcher in the Rye"},"date":{"type":"gd:when","value":"1951/7/16 0:0:0"},"classic":{"type":"bool","value":true},"pages":{"type":"int","value":288},"tags":{"type":"string","value":["novel","identity"]}}},"6eb9a4d405f3ee6c67e965b7693108d2"],"id":3}'
        )

        self.assertEqual("200 OK", res.status)
        self.assertEqual(
            simplejson.loads(res.body), {
                u'jsonrpc': u'2.0',
                u'result': {
                    u'status': 3,
                    u'version': 1,
                    u'key': u'dGVzdEBkZWZhdWx0ISFCb29rCjI='
                },
                u'id': 3
            })

        res = app.post(
            '/gaesynkit/rpc/',
            '{"jsonrpc":"2.0","method":"syncEntity","params":[{"kind":"Book","key":"dGVzdEBkZWZhdWx0ISFCb29rCjI=","version":1,"id":2,"properties":{"title":{"type":"string","value":"The Catcher in the Rye"},"date":{"type":"gd:when","value":"1951/7/16 0:0:0"},"classic":{"type":"bool","value":true},"pages":{"type":"int","value":287},"tags":{"type":"string","value":["novel","identity"]}}},"7ec49827a52b56fdd24b07410c9bf0d6"],"id":4}'
        )

        self.assertEqual("200 OK", res.status)
        self.assertEqual(
            simplejson.loads(res.body), {
                u'jsonrpc': u'2.0',
                u'result': {
                    u'status': 2,
                    u'entity': {
                        u'kind': u'Book',
                        u'version': 2,
                        u'properties': {
                            u'date': {
                                u'type': u'gd:when',
                                u'value': u'1951/07/16 00:00:00'
                            },
                            u'classic': {
                                u'type': u'bool',
                                u'value': True
                            },
                            u'pages': {
                                u'type': u'int',
                                u'value': 287
                            },
                            u'tags': {
                                u'type': u'string',
                                u'value': [u'novel', u'identity']
                            },
                            u'title': {
                                u'type': u'string',
                                u'value': u'The Catcher in the Rye'
                            }
                        },
                        u'key': u'dGVzdEBkZWZhdWx0ISFCb29rCjI=',
                        u'id': 1
                    }
                },
                u'id': 4
            })

        res = app.post(
            '/gaesynkit/rpc/',
            '{"jsonrpc":"2.0","method":"syncEntity","params":[{"kind":"Book","key":"dGVzdEBkZWZhdWx0ISFCb29rCjI=","version":0,"id":2,"properties":{"title":{"type":"string","value":"The Catcher in the Rye"},"date":{"type":"gd:when","value":"1951/7/16 0:0:0"},"classic":{"type":"bool","value":true},"pages":{"type":"int","value":287},"tags":{"type":"string","value":["novel","identity"]}}},"7ec49827a52b56fdd24b07410c9bf0d6"],"id":4}'
        )

        self.assertEqual("200 OK", res.status)
Ejemplo n.º 32
0
class TestFulltext(TestCase):
    """Test that our fulltext classes function"""
    def setUp(self):
        """Setup Tests"""
        from pyramid.paster import get_app
        from bookie.tests import BOOKIE_TEST_INI
        app = get_app(BOOKIE_TEST_INI, 'main')
        from webtest import TestApp
        self.testapp = TestApp(app)
        testing.setUp()
        global API_KEY
        if API_KEY is None:
            res = DBSession.execute(
                "SELECT api_key FROM users WHERE username = '******'").\
                fetchone()
            API_KEY = res['api_key']

    def tearDown(self):
        """Tear down each test"""
        testing.tearDown()
        empty_db()

    def _get_good_request(self, new_tags=None):
        """Return the basics for a good add bookmark request"""
        session = DBSession()
        prms = {
            'url': u'http://google.com',
            'description': u'This is my google desc SEE',
            'extended': u'And some extended notes about it in full form',
            'tags': u'python search',
            'api_key': API_KEY,
        }

        if new_tags:
            prms['tags'] = new_tags

        req_params = urllib.urlencode(prms)
        res = self.testapp.post('/api/v1/admin/bmark', params=req_params)

        session.flush()
        transaction.commit()
        return res

    def test_get_handler(self):
        """Verify we get the right type of full text store object"""
        handler = get_fulltext_handler("")

        ok_(isinstance(handler, WhooshFulltext),
            "Should get a whoosh fulltext by default")

    def test_sqlite_save(self):
        """Verify that if we store a bookmark we get the fulltext storage"""
        # first let's add a bookmark we can search on
        self._get_good_request()

        search_res = self.testapp.get('/api/v1/admin/bmarks/search/google')
        ok_(search_res.status == '200 OK',
            "Status is 200: " + search_res.status)
        ok_('my google desc' in search_res.body,
            "We should find our description on the page: " + search_res.body)

        search_res = self.testapp.get('/api/v1/admin/bmarks/search/python')
        ok_(search_res.status == '200 OK',
            "Status is 200: " + search_res.status)

        ok_('my google desc' in search_res.body,
            "Tag search should find our description on the page: " + \
                search_res.body)

        search_res = self.testapp.get(
            '/api/v1/admin/bmarks/search/extended%20notes')
        ok_(search_res.status == '200 OK',
            "Status is 200: " + search_res.status)
        ok_('extended notes' in search_res.body,
            "Extended search should find our description on the page: " + \
                search_res.body)

    def test_sqlite_update(self):
        """Verify that if we update a bookmark, fulltext is updated

        We need to make sure that updates to the record get cascaded into the
        fulltext table indexes

        """
        self._get_good_request()

        # now we need to do another request with updated tag string
        self._get_good_request(new_tags="google books icons")

        search_res = self.testapp.get('/admin/results?search=icon')
        ok_(search_res.status == '200 OK',
            "Status is 200: " + search_res.status)

        ok_('icon' in search_res.body,
            "We should find the new tag icon on the page: " + search_res.body)

    def test_ajax_search(self):
        """Verify that we can get a json MorJSON response when ajax search"""
        # first let's add a bookmark we can search on
        self._get_good_request()

        search_res = self.testapp.get('/admin/results/google',
                                      headers={
                                          'X-Requested-With': 'XMLHttpRequest',
                                          'Accept': 'application/json'
                                      })

        ok_(search_res.status == '200 OK',
            "Status is 200: " + search_res.status)

        ok_('my google desc' in search_res.body,
            "We should find our description on the page: " + search_res.body)

        # also check for our specific json bits
        ok_('success' in search_res.body,
            "We should see a success bit in the json: " + search_res.body)

        ok_('payload' in search_res.body,
            "We should see a payload bit in the json: " + search_res.body)

        ok_('message' in search_res.body,
            "We should see a message bit in the json: " + search_res.body)
Ejemplo n.º 33
0
def testapp(app):
    """Create Webtest app."""
    return TestApp(app)
Ejemplo n.º 34
0
    def setUp(self):
        super(FunctionalTestBase, self).setUp()

        self.settings = self.get_settings()
        app = main(None, **self.settings)
        self.testapp = TestApp(app)
 def setUp(self):
     from restful_auto_service import main
     app = main({})
     from webtest import TestApp
     self.testapp = TestApp(app)
Ejemplo n.º 36
0
    def setUp(self):
        from tutorial import main
        app = main({})
        from webtest import TestApp

        self.testapp = TestApp(app)
Ejemplo n.º 37
0
 def setUp(self):
     app = create_app
     self.client = TestApp(app)
Ejemplo n.º 38
0
    def test_accept(self):
        # tests that the accept headers are handled the proper way
        app = TestApp(main({}))

        # requesting the wrong accept header should return a 406 ...
        response = app.get('/service2', headers={'Accept': 'audio/*'},
                           status=406)

        # ... with the list of accepted content-types
        error_location = response.json['errors'][0]['location']
        error_name = response.json['errors'][0]['name']
        error_description = response.json['errors'][0]['description']
        self.assertEquals('header', error_location)
        self.assertEquals('Accept', error_name)
        self.assertTrue('application/json' in error_description)
        self.assertTrue('text/json' in error_description)
        self.assertTrue('text/plain' in error_description)

        # requesting a supported type should give an appropriate response type
        response = app.get('/service2', headers={'Accept': 'application/*'})
        self.assertEqual(response.content_type, "application/json")

        response = app.get('/service2', headers={'Accept': 'text/plain'})
        self.assertEqual(response.content_type, "text/plain")

        # it should also work with multiple Accept headers
        response = app.get('/service2', headers={
            'Accept': 'audio/*, application/*'
        })
        self.assertEqual(response.content_type, "application/json")

        # and requested preference order should be respected
        headers = {'Accept': 'application/json; q=1.0, text/plain; q=0.9'}
        response = app.get('/service2', headers=headers)
        self.assertEqual(response.content_type, "application/json")

        headers = {'Accept': 'application/json; q=0.9, text/plain; q=1.0'}
        response = app.get('/service2', headers=headers)
        self.assertEqual(response.content_type, "text/plain")

        # test that using a callable to define what's accepted works as well
        response = app.get('/service3', headers={'Accept': 'audio/*'},
                           status=406)
        error_description = response.json['errors'][0]['description']
        self.assertTrue('text/json' in error_description)

        response = app.get('/service3', headers={'Accept': 'text/*'})
        self.assertEqual(response.content_type, "text/json")

        # if we are not asking for a particular content-type,
        # we should get one of the two types that the service supports.
        response = app.get('/service2')
        self.assertTrue(response.content_type
                        in ("application/json", "text/plain"))
Ejemplo n.º 39
0
 def make_app_with_deserializer(self, deserializer):
     config = Configurator(settings={})
     config.include(includeme)
     config.add_cornice_deserializer('text/dummy', deserializer)
     return TestApp(CatchErrors(config.make_wsgi_app()))
Ejemplo n.º 40
0
 def setUp(self):
     from ogcpywps import main
     app = main({})
     from webtest import TestApp
     self.testapp = TestApp(app)
Ejemplo n.º 41
0
 def test_content_type_on_get(self):
     # test that a Content-Type request header is not
     # checked on GET requests, they don't usually have a body
     app = TestApp(main({}))
     response = app.get('/service5')
     self.assertEqual(response.json, "some response")
Ejemplo n.º 42
0
    def test_validation_hooked_error_response(self):
        app = TestApp(main({}))

        response = app.post('/service4', status=400)
        self.assertTrue(b'<errors>' in response.body)
Ejemplo n.º 43
0
    def test_filters(self):
        app = TestApp(main({}))

        # filters can be applied to all the methods of a service
        self.assertTrue(b"filtered response" in app.get('/filtered').body)
        self.assertTrue(b"unfiltered" in app.post('/filtered').body)
Ejemplo n.º 44
0
 def make_ordinary_app(self):
     return TestApp(main({}))
Ejemplo n.º 45
0
    def test_accept_issue_113_text_application_json(self):
        app = TestApp(main({}))

        response = app.get('/service3', headers={'Accept': 'application/json'})
        self.assertEqual(response.content_type, "application/json")
Ejemplo n.º 46
0
 def test_email_field(self):
     app = TestApp(main({}))
     content = {'email': '*****@*****.**'}
     app.post_json('/newsletter', params=content)
Ejemplo n.º 47
0
 def __init__(self):
     self.test_core = TestApp(Core().execute_wsgi())
Ejemplo n.º 48
0
    def test_accept_issue_113_text_html_not_acceptable(self):
        app = TestApp(main({}))

        # requesting an unsupported content type should return a HTTP 406 (Not
        # Acceptable)
        app.get('/service3', headers={'Accept': 'text/html'}, status=406)
Ejemplo n.º 49
0
class Cs_Subcommands_test(Cs_Handlers_test):
    def GoTo_Basic_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        goto_data = self._BuildRequest(completer_target='filetype_default',
                                       command_arguments=['GoTo'],
                                       line_num=9,
                                       column_num=15,
                                       contents=contents,
                                       filetype='cs',
                                       filepath=filepath)

        eq_(
            {
                'filepath': self._PathToTestFile('testy', 'Program.cs'),
                'line_num': 7,
                'column_num': 3
            },
            self._app.post_json('/run_completer_command', goto_data).json)

        self._StopOmniSharpServer(filepath)

    def GoToImplementation_Basic_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        goto_data = self._BuildRequest(
            completer_target='filetype_default',
            command_arguments=['GoToImplementation'],
            line_num=13,
            column_num=13,
            contents=contents,
            filetype='cs',
            filepath=filepath)

        eq_(
            {
                'filepath': self._PathToTestFile('testy', 'GotoTestCase.cs'),
                'line_num': 30,
                'column_num': 3
            },
            self._app.post_json('/run_completer_command', goto_data).json)

        self._StopOmniSharpServer(filepath)

    def GoToImplementation_NoImplementation_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        goto_data = self._BuildRequest(
            completer_target='filetype_default',
            command_arguments=['GoToImplementation'],
            line_num=17,
            column_num=13,
            contents=contents,
            filetype='cs',
            filepath=filepath)

        try:
            self._app.post_json('/run_completer_command', goto_data).json
            raise Exception("Expected a 'No implementations found' error")
        except AppError as e:
            if 'No implementations found' in str(e):
                pass
            else:
                raise
        finally:
            self._StopOmniSharpServer(filepath)

    def CsCompleter_InvalidLocation_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        goto_data = self._BuildRequest(
            completer_target='filetype_default',
            command_arguments=['GoToImplementation'],
            line_num=2,
            column_num=1,
            contents=contents,
            filetype='cs',
            filepath=filepath)

        try:
            self._app.post_json('/run_completer_command', goto_data).json
            raise Exception(
                'Expected a "Can\\\'t jump to implementation" error')
        except AppError as e:
            if 'Can\\\'t jump to implementation' in str(e):
                pass
            else:
                raise
        finally:
            self._StopOmniSharpServer(filepath)

    def GoToImplementationElseDeclaration_NoImplementation_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        goto_data = self._BuildRequest(
            completer_target='filetype_default',
            command_arguments=['GoToImplementationElseDeclaration'],
            line_num=17,
            column_num=13,
            contents=contents,
            filetype='cs',
            filepath=filepath)

        eq_(
            {
                'filepath': self._PathToTestFile('testy', 'GotoTestCase.cs'),
                'line_num': 35,
                'column_num': 3
            },
            self._app.post_json('/run_completer_command', goto_data).json)

        self._StopOmniSharpServer(filepath)

    def GoToImplementationElseDeclaration_SingleImplementation_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        goto_data = self._BuildRequest(
            completer_target='filetype_default',
            command_arguments=['GoToImplementationElseDeclaration'],
            line_num=13,
            column_num=13,
            contents=contents,
            filetype='cs',
            filepath=filepath)

        eq_(
            {
                'filepath': self._PathToTestFile('testy', 'GotoTestCase.cs'),
                'line_num': 30,
                'column_num': 3
            },
            self._app.post_json('/run_completer_command', goto_data).json)

        self._StopOmniSharpServer(filepath)

    def GoToImplementationElseDeclaration_MultipleImplementations_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        goto_data = self._BuildRequest(
            completer_target='filetype_default',
            command_arguments=['GoToImplementationElseDeclaration'],
            line_num=21,
            column_num=13,
            contents=contents,
            filetype='cs',
            filepath=filepath)

        eq_([{
            'filepath': self._PathToTestFile('testy', 'GotoTestCase.cs'),
            'line_num': 43,
            'column_num': 3
        }, {
            'filepath': self._PathToTestFile('testy', 'GotoTestCase.cs'),
            'line_num': 48,
            'column_num': 3
        }],
            self._app.post_json('/run_completer_command', goto_data).json)

        self._StopOmniSharpServer(filepath)

    def GetType_EmptyMessage_test(self):
        filepath = self._PathToTestFile('testy', 'GetTypeTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        gettype_data = self._BuildRequest(completer_target='filetype_default',
                                          command_arguments=['GetType'],
                                          line_num=1,
                                          column_num=1,
                                          contents=contents,
                                          filetype='cs',
                                          filepath=filepath)

        eq_({u'message': u""},
            self._app.post_json('/run_completer_command', gettype_data).json)

        self._StopOmniSharpServer(filepath)

    def GetType_VariableDeclaration_test(self):
        filepath = self._PathToTestFile('testy', 'GetTypeTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        gettype_data = self._BuildRequest(completer_target='filetype_default',
                                          command_arguments=['GetType'],
                                          line_num=4,
                                          column_num=5,
                                          contents=contents,
                                          filetype='cs',
                                          filepath=filepath)

        eq_({u'message': u"string"},
            self._app.post_json('/run_completer_command', gettype_data).json)

        self._StopOmniSharpServer(filepath)

    def GetType_VariableUsage_test(self):
        filepath = self._PathToTestFile('testy', 'GetTypeTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        gettype_data = self._BuildRequest(completer_target='filetype_default',
                                          command_arguments=['GetType'],
                                          line_num=5,
                                          column_num=5,
                                          contents=contents,
                                          filetype='cs',
                                          filepath=filepath)

        eq_({u'message': u"string str"},
            self._app.post_json('/run_completer_command', gettype_data).json)

        self._StopOmniSharpServer(filepath)

    def GetType_Constant_test(self):
        filepath = self._PathToTestFile('testy', 'GetTypeTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        gettype_data = self._BuildRequest(completer_target='filetype_default',
                                          command_arguments=['GetType'],
                                          line_num=4,
                                          column_num=14,
                                          contents=contents,
                                          filetype='cs',
                                          filepath=filepath)

        eq_({u'message': u"System.String"},
            self._app.post_json('/run_completer_command', gettype_data).json)

        self._StopOmniSharpServer(filepath)

    def GetType_DocsIgnored_test(self):
        filepath = self._PathToTestFile('testy', 'GetTypeTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        gettype_data = self._BuildRequest(completer_target='filetype_default',
                                          command_arguments=['GetType'],
                                          line_num=9,
                                          column_num=34,
                                          contents=contents,
                                          filetype='cs',
                                          filepath=filepath)

        eq_({
            u'message': u"int GetTypeTestCase.an_int_with_docs;",
        },
            self._app.post_json('/run_completer_command', gettype_data).json)

        self._StopOmniSharpServer(filepath)

    def GetDoc_Variable_test(self):
        filepath = self._PathToTestFile('testy', 'GetDocTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        getdoc_data = self._BuildRequest(completer_target='filetype_default',
                                         command_arguments=['GetDoc'],
                                         line_num=13,
                                         column_num=28,
                                         contents=contents,
                                         filetype='cs',
                                         filepath=filepath)

        eq_(
            {
                'detailed_info':
                'int GetDocTestCase.an_int;\n'
                'an integer, or something',
            },
            self._app.post_json('/run_completer_command', getdoc_data).json)

        self._StopOmniSharpServer(filepath)

    def GetDoc_Function_test(self):
        filepath = self._PathToTestFile('testy', 'GetDocTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        getdoc_data = self._BuildRequest(completer_target='filetype_default',
                                         command_arguments=['GetDoc'],
                                         line_num=33,
                                         column_num=27,
                                         contents=contents,
                                         filetype='cs',
                                         filepath=filepath)

        # It seems that Omnisharp server eats newlines
        eq_(
            {
                'detailed_info':
                'int GetDocTestCase.DoATest();\n'
                ' Very important method. With multiple lines of '
                'commentary And Format- -ting',
            },
            self._app.post_json('/run_completer_command', getdoc_data).json)

        self._StopOmniSharpServer(filepath)

    def _RunFixIt(self, line, column, expected_result):
        filepath = self._PathToTestFile('testy', 'FixItTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        fixit_data = self._BuildRequest(completer_target='filetype_default',
                                        command_arguments=['FixIt'],
                                        line_num=line,
                                        column_num=column,
                                        contents=contents,
                                        filetype='cs',
                                        filepath=filepath)

        eq_(expected_result,
            self._app.post_json('/run_completer_command', fixit_data).json)

        self._StopOmniSharpServer(filepath)

    def FixIt_RemoveSingleLine_test(self):
        filepath = self._PathToTestFile('testy', 'FixItTestCase.cs')
        self._RunFixIt(
            11, 1, {
                u'fixits': [{
                    u'location': {
                        u'line_num': 11,
                        u'column_num': 1,
                        u'filepath': filepath
                    },
                    u'chunks': [{
                        u'replacement_text': '',
                        u'range': {
                            u'start': {
                                u'line_num': 10,
                                u'column_num': 20,
                                u'filepath': filepath
                            },
                            u'end': {
                                u'line_num': 11,
                                u'column_num': 30,
                                u'filepath': filepath
                            },
                        }
                    }]
                }]
            })

    def FixIt_MultipleLines_test(self):
        filepath = self._PathToTestFile('testy', 'FixItTestCase.cs')
        self._RunFixIt(
            19, 1, {
                u'fixits': [{
                    u'location': {
                        u'line_num': 19,
                        u'column_num': 1,
                        u'filepath': filepath
                    },
                    u'chunks': [{
                        u'replacement_text': "return On",
                        u'range': {
                            u'start': {
                                u'line_num': 20,
                                u'column_num': 13,
                                u'filepath': filepath
                            },
                            u'end': {
                                u'line_num': 21,
                                u'column_num': 35,
                                u'filepath': filepath
                            },
                        }
                    }]
                }]
            })

    def FixIt_SpanFileEdge_test(self):
        filepath = self._PathToTestFile('testy', 'FixItTestCase.cs')
        self._RunFixIt(
            1, 1, {
                u'fixits': [{
                    u'location': {
                        u'line_num': 1,
                        u'column_num': 1,
                        u'filepath': filepath
                    },
                    u'chunks': [{
                        u'replacement_text': 'System',
                        u'range': {
                            u'start': {
                                u'line_num': 1,
                                u'column_num': 7,
                                u'filepath': filepath
                            },
                            u'end': {
                                u'line_num': 3,
                                u'column_num': 18,
                                u'filepath': filepath
                            },
                        }
                    }]
                }]
            })

    def FixIt_AddTextInLine_test(self):
        filepath = self._PathToTestFile('testy', 'FixItTestCase.cs')
        self._RunFixIt(
            9, 1, {
                u'fixits': [{
                    u'location': {
                        u'line_num': 9,
                        u'column_num': 1,
                        u'filepath': filepath
                    },
                    u'chunks': [{
                        u'replacement_text': ', StringComparison.Ordinal',
                        u'range': {
                            u'start': {
                                u'line_num': 9,
                                u'column_num': 29,
                                u'filepath': filepath
                            },
                            u'end': {
                                u'line_num': 9,
                                u'column_num': 29,
                                u'filepath': filepath
                            },
                        }
                    }]
                }]
            })

    def FixIt_ReplaceTextInLine_test(self):
        filepath = self._PathToTestFile('testy', 'FixItTestCase.cs')
        self._RunFixIt(
            10, 1, {
                u'fixits': [{
                    u'location': {
                        u'line_num': 10,
                        u'column_num': 1,
                        u'filepath': filepath
                    },
                    u'chunks': [{
                        u'replacement_text': 'const int',
                        u'range': {
                            u'start': {
                                u'line_num': 10,
                                u'column_num': 13,
                                u'filepath': filepath
                            },
                            u'end': {
                                u'line_num': 10,
                                u'column_num': 16,
                                u'filepath': filepath
                            },
                        }
                    }]
                }]
            })

    def StopServer_NoErrorIfNotStarted_test(self):
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        self._StopOmniSharpServer(filepath)
        # Success = no raise

    def StopServer_KeepLogFiles_test(self):
        yield self._StopServer_KeepLogFiles, True
        yield self._StopServer_KeepLogFiles, False

    def _StopServer_KeepLogFiles(self, keeping_log_files):
        self._ChangeSpecificOptions(
            {'server_keep_logfiles': keeping_log_files})
        self._app = TestApp(handlers.app)
        self._app.post_json(
            '/ignore_extra_conf_file',
            {'filepath': self._PathToTestFile('.ycm_extra_conf.py')})
        filepath = self._PathToTestFile('testy', 'GotoTestCase.cs')
        contents = open(filepath).read()
        event_data = self._BuildRequest(filepath=filepath,
                                        filetype='cs',
                                        contents=contents,
                                        event_name='FileReadyToParse')

        self._app.post_json('/event_notification', event_data)
        self._WaitUntilOmniSharpServerReady(filepath)

        event_data = self._BuildRequest(filetype='cs', filepath=filepath)

        debuginfo = self._app.post_json('/debug_info', event_data).json

        log_files_match = re.search("^OmniSharp logfiles:\n(.*)\n(.*)",
                                    debuginfo, re.MULTILINE)
        stdout_logfiles_location = log_files_match.group(1)
        stderr_logfiles_location = log_files_match.group(2)

        try:
            ok_(os.path.exists(stdout_logfiles_location),
                "Logfile should exist at {0}".format(stdout_logfiles_location))
            ok_(os.path.exists(stderr_logfiles_location),
                "Logfile should exist at {0}".format(stderr_logfiles_location))
        finally:
            self._StopOmniSharpServer(filepath)

        if keeping_log_files:
            ok_(
                os.path.exists(stdout_logfiles_location),
                "Logfile should still exist at "
                "{0}".format(stdout_logfiles_location))
            ok_(
                os.path.exists(stderr_logfiles_location),
                "Logfile should still exist at "
                "{0}".format(stderr_logfiles_location))
        else:
            ok_(
                not os.path.exists(stdout_logfiles_location),
                "Logfile should no longer exist at "
                "{0}".format(stdout_logfiles_location))
            ok_(
                not os.path.exists(stderr_logfiles_location),
                "Logfile should no longer exist at "
                "{0}".format(stderr_logfiles_location))
Ejemplo n.º 50
0
    def test_accept_issue_113_text_star(self):
        app = TestApp(main({}))

        response = app.get('/service3', headers={'Accept': 'text/*'})
        self.assertEqual(response.content_type, "text/json")
Ejemplo n.º 51
0
def testapp(app):
    """A Webtest app."""
    return TestApp(app)
Ejemplo n.º 52
0
class Client(object):
    def __init__(self):
        self.test_core = TestApp(Core().execute_wsgi())

    def get_api(self, api_url, *auth):
        response = APIResponse()
        __api_url = str(api_url)
        if auth:
            self.test_core.set_authorization(auth)
        test_core_response = self.test_core.get(__api_url)
        response.json = test_core_response.json
        response.status = test_core_response.status
        response.status_code = test_core_response.status_code
        response.body = test_core_response.body
        response.content_type = test_core_response.content_type

        return response

    def post_api(self, api_url, data, *auth):
        response = APIResponse()
        __api_url = str(api_url)
        if auth:
            self.test_core.set_authorization(auth)
        test_core_response = self.test_core.post_json(__api_url, params=data)
        response.json = json.dumps(test_core_response.json)
        response.status = test_core_response.status
        response.status_code = test_core_response.status_code
        response.body = test_core_response.body
        return response

    def patch_api(self, api_url, data, *auth):
        response = APIResponse()
        __api_url = str(api_url)
        if auth:
            self.test_core.set_authorization(auth)
        test_core_response = self.test_core.patch_json(__api_url, params=data)
        response.json = json.dumps(test_core_response.json)
        response.status = test_core_response.status
        response.status_code = test_core_response.status_code
        response.body = test_core_response.body
        return response

    def put_api(self, api_url, data, *auth):
        response = APIResponse()
        __api_url = str(api_url)
        if auth:
            self.test_core.set_authorization(auth)
        test_core_response = self.test_core.put_json(__api_url, params=data)
        response.json = json.dumps(test_core_response.json)
        response.status = test_core_response.status
        response.status_code = test_core_response.status_code
        response.body = test_core_response.body
        return response

    def delete_api(self, api_url, data, *auth):
        response = APIResponse()
        __api_url = str(api_url)
        if auth:
            self.test_core.set_authorization(auth)
        test_core_response = self.test_core.delete_json(__api_url, params=data)
        response.json = json.dumps(test_core_response.json)
        response.status = test_core_response.status
        response.status_code = test_core_response.status_code
        response.body = test_core_response.body
        return response
Ejemplo n.º 53
0
    def test_custom_delete(self):

        class OthersController(object):

            @expose()
            def index(self):
                return 'DELETE'

            @expose()
            def reset(self, id):
                return str(id)

        class ThingsController(RestController):

            others = OthersController()

            @expose()
            def delete_fail(self):
                abort(500)

        class RootController(object):
            things = ThingsController()

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

        # test bad delete
        r = app.delete('/things/delete_fail', status=405)
        assert r.status_int == 405

        # test bad delete with _method parameter and GET
        r = app.get('/things/delete_fail?_method=delete', status=405)
        assert r.status_int == 405

        # test bad delete with _method parameter and POST
        r = app.post('/things/delete_fail', {'_method': 'delete'}, status=405)
        assert r.status_int == 405

        # test custom delete without ID
        r = app.delete('/things/others/')
        assert r.status_int == 200
        assert r.body == b_('DELETE')

        # test custom delete without ID with _method parameter and GET
        r = app.get('/things/others/?_method=delete', status=405)
        assert r.status_int == 405

        # test custom delete without ID with _method parameter and POST
        r = app.post('/things/others/', {'_method': 'delete'})
        assert r.status_int == 200
        assert r.body == b_('DELETE')

        # test custom delete with ID
        r = app.delete('/things/others/reset/1')
        assert r.status_int == 200
        assert r.body == b_('1')

        # test custom delete with ID with _method parameter and GET
        r = app.get('/things/others/reset/1?_method=delete', status=405)
        assert r.status_int == 405

        # test custom delete with ID with _method parameter and POST
        r = app.post('/things/others/reset/1', {'_method': 'delete'})
        assert r.status_int == 200
        assert r.body == b_('1')
 def setUpClass(cls):
     cls.app = TestApp(app)
Ejemplo n.º 55
0
    def test_complicated_nested_rest(self):

        class BarsController(RestController):

            data = [['zero-zero', 'zero-one'], ['one-zero', 'one-one']]

            @expose()
            def get_one(self, foo_id, id):
                return self.data[int(foo_id)][int(id)]

            @expose('json')
            def get_all(self, foo_id):
                return dict(items=self.data[int(foo_id)])

            @expose()
            def new(self, foo_id):
                return 'NEW FOR %s' % foo_id

            @expose()
            def post(self, foo_id, value):
                foo_id = int(foo_id)
                if len(self.data) < foo_id + 1:
                    self.data.extend([[]] * (foo_id - len(self.data) + 1))
                self.data[foo_id].append(value)
                response.status = 302
                return 'CREATED FOR %s' % foo_id

            @expose()
            def edit(self, foo_id, id):
                return 'EDIT %s' % self.data[int(foo_id)][int(id)]

            @expose()
            def put(self, foo_id, id, value):
                self.data[int(foo_id)][int(id)] = value
                return 'UPDATED'

            @expose()
            def get_delete(self, foo_id, id):
                return 'DELETE %s' % self.data[int(foo_id)][int(id)]

            @expose()
            def delete(self, foo_id, id):
                del self.data[int(foo_id)][int(id)]
                return 'DELETED'

        class FoosController(RestController):

            data = ['zero', 'one']

            bars = BarsController()

            @expose()
            def get_one(self, id):
                return self.data[int(id)]

            @expose('json')
            def get_all(self):
                return dict(items=self.data)

            @expose()
            def new(self):
                return 'NEW'

            @expose()
            def edit(self, id):
                return 'EDIT %s' % self.data[int(id)]

            @expose()
            def post(self, value):
                self.data.append(value)
                response.status = 302
                return 'CREATED'

            @expose()
            def put(self, id, value):
                self.data[int(id)] = value
                return 'UPDATED'

            @expose()
            def get_delete(self, id):
                return 'DELETE %s' % self.data[int(id)]

            @expose()
            def delete(self, id):
                del self.data[int(id)]
                return 'DELETED'

        class RootController(object):
            foos = FoosController()

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

        # test get_all
        r = app.get('/foos')
        assert r.status_int == 200
        assert r.body == b_(dumps(dict(items=FoosController.data)))

        # test nested get_all
        r = app.get('/foos/1/bars')
        assert r.status_int == 200
        assert r.body == b_(dumps(dict(items=BarsController.data[1])))

        # test get_one
        for i, value in enumerate(FoosController.data):
            r = app.get('/foos/%d' % i)
            assert r.status_int == 200
            assert r.body == b_(value)

        # test nested get_one
        for i, value in enumerate(FoosController.data):
            for j, value in enumerate(BarsController.data[i]):
                r = app.get('/foos/%s/bars/%s' % (i, j))
                assert r.status_int == 200
                assert r.body == b_(value)

        # test post
        r = app.post('/foos', {'value': 'two'})
        assert r.status_int == 302
        assert r.body == b_('CREATED')

        # make sure it works
        r = app.get('/foos/2')
        assert r.status_int == 200
        assert r.body == b_('two')

        # test nested post
        r = app.post('/foos/2/bars', {'value': 'two-zero'})
        assert r.status_int == 302
        assert r.body == b_('CREATED FOR 2')

        # make sure it works
        r = app.get('/foos/2/bars/0')
        assert r.status_int == 200
        assert r.body == b_('two-zero')

        # test edit
        r = app.get('/foos/1/edit')
        assert r.status_int == 200
        assert r.body == b_('EDIT one')

        # test nested edit
        r = app.get('/foos/1/bars/1/edit')
        assert r.status_int == 200
        assert r.body == b_('EDIT one-one')

        # test put
        r = app.put('/foos/2', {'value': 'TWO'})
        assert r.status_int == 200
        assert r.body == b_('UPDATED')

        # make sure it works
        r = app.get('/foos/2')
        assert r.status_int == 200
        assert r.body == b_('TWO')

        # test nested put
        r = app.put('/foos/2/bars/0', {'value': 'TWO-ZERO'})
        assert r.status_int == 200
        assert r.body == b_('UPDATED')

        # make sure it works
        r = app.get('/foos/2/bars/0')
        assert r.status_int == 200
        assert r.body == b_('TWO-ZERO')

        # test put with _method parameter and GET
        r = app.get('/foos/2?_method=put', {'value': 'TWO!'}, status=405)
        assert r.status_int == 405

        # make sure it works
        r = app.get('/foos/2')
        assert r.status_int == 200
        assert r.body == b_('TWO')

        # test nested put with _method parameter and GET
        r = app.get(
            '/foos/2/bars/0?_method=put',
            {'value': 'ZERO-TWO!'}, status=405
        )
        assert r.status_int == 405

        # make sure it works
        r = app.get('/foos/2/bars/0')
        assert r.status_int == 200
        assert r.body == b_('TWO-ZERO')

        # test put with _method parameter and POST
        r = app.post('/foos/2?_method=put', {'value': 'TWO!'})
        assert r.status_int == 200
        assert r.body == b_('UPDATED')

        # make sure it works
        r = app.get('/foos/2')
        assert r.status_int == 200
        assert r.body == b_('TWO!')

        # test nested put with _method parameter and POST
        r = app.post('/foos/2/bars/0?_method=put', {'value': 'TWO-ZERO!'})
        assert r.status_int == 200
        assert r.body == b_('UPDATED')

        # make sure it works
        r = app.get('/foos/2/bars/0')
        assert r.status_int == 200
        assert r.body == b_('TWO-ZERO!')

        # test get delete
        r = app.get('/foos/2/delete')
        assert r.status_int == 200
        assert r.body == b_('DELETE TWO!')

        # test nested get delete
        r = app.get('/foos/2/bars/0/delete')
        assert r.status_int == 200
        assert r.body == b_('DELETE TWO-ZERO!')

        # test nested delete
        r = app.delete('/foos/2/bars/0')
        assert r.status_int == 200
        assert r.body == b_('DELETED')

        # make sure it works
        r = app.get('/foos/2/bars')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 0

        # test delete
        r = app.delete('/foos/2')
        assert r.status_int == 200
        assert r.body == b_('DELETED')

        # make sure it works
        r = app.get('/foos')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 2

        # test nested delete with _method parameter and GET
        r = app.get('/foos/1/bars/1?_method=DELETE', status=405)
        assert r.status_int == 405

        # make sure it works
        r = app.get('/foos/1/bars')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 2

        # test delete with _method parameter and GET
        r = app.get('/foos/1?_method=DELETE', status=405)
        assert r.status_int == 405

        # make sure it works
        r = app.get('/foos')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 2

        # test nested delete with _method parameter and POST
        r = app.post('/foos/1/bars/1?_method=DELETE')
        assert r.status_int == 200
        assert r.body == b_('DELETED')

        # make sure it works
        r = app.get('/foos/1/bars')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 1

        # test delete with _method parameter and POST
        r = app.post('/foos/1?_method=DELETE')
        assert r.status_int == 200
        assert r.body == b_('DELETED')

        # make sure it works
        r = app.get('/foos')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 1
Ejemplo n.º 56
0
 def __init__(self, *args, **kwargs):
     wsgiapp = pylons.test.pylonsapp
     config = wsgiapp.config
     self.app = TestApp(wsgiapp)
     url._push_object(URLGenerator(config['routes.map'], environ))
Ejemplo n.º 57
0
    def test_dynamic_rest_lookup(self):
        class BarController(RestController):
            @expose()
            def get_all(self):
                return "BAR"

            @expose()
            def put(self):
                return "PUT_BAR"

            @expose()
            def delete(self):
                return "DELETE_BAR"

        class BarsController(RestController):
            @expose()
            def _lookup(self, id_, *remainder):
                return BarController(), remainder

            @expose()
            def get_all(self):
                return "BARS"

            @expose()
            def post(self):
                return "POST_BARS"

        class FooController(RestController):
            bars = BarsController()

            @expose()
            def get_all(self):
                return "FOO"

            @expose()
            def put(self):
                return "PUT_FOO"

            @expose()
            def delete(self):
                return "DELETE_FOO"

        class FoosController(RestController):
            @expose()
            def _lookup(self, id_, *remainder):
                return FooController(), remainder

            @expose()
            def get_all(self):
                return "FOOS"

            @expose()
            def post(self):
                return "POST_FOOS"

        class RootController(RestController):
            foos = FoosController()

        app = TestApp(make_app(RootController()))

        r = app.get('/foos')
        assert r.status_int == 200
        assert r.body == b_('FOOS')

        r = app.post('/foos')
        assert r.status_int == 200
        assert r.body == b_('POST_FOOS')

        r = app.get('/foos/foo')
        assert r.status_int == 200
        assert r.body == b_('FOO')

        r = app.put('/foos/foo')
        assert r.status_int == 200
        assert r.body == b_('PUT_FOO')

        r = app.delete('/foos/foo')
        assert r.status_int == 200
        assert r.body == b_('DELETE_FOO')

        r = app.get('/foos/foo/bars')
        assert r.status_int == 200
        assert r.body == b_('BARS')

        r = app.post('/foos/foo/bars')
        assert r.status_int == 200
        assert r.body == b_('POST_BARS')

        r = app.get('/foos/foo/bars/bar')
        assert r.status_int == 200
        assert r.body == b_('BAR')

        r = app.put('/foos/foo/bars/bar')
        assert r.status_int == 200
        assert r.body == b_('PUT_BAR')

        r = app.delete('/foos/foo/bars/bar')
        assert r.status_int == 200
        assert r.body == b_('DELETE_BAR')
Ejemplo n.º 58
0
    def test_bad_rest(self):

        class ThingsController(RestController):
            pass

        class RootController(object):
            things = ThingsController()

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

        # test get_all
        r = app.get('/things', status=405)
        assert r.status_int == 405

        # test get_one
        r = app.get('/things/1', status=405)
        assert r.status_int == 405

        # test post
        r = app.post('/things', {'value': 'one'}, status=405)
        assert r.status_int == 405

        # test edit
        r = app.get('/things/1/edit', status=405)
        assert r.status_int == 405

        # test put
        r = app.put('/things/1', {'value': 'ONE'}, status=405)

        # test put with _method parameter and GET
        r = app.get('/things/1?_method=put', {'value': 'ONE!'}, status=405)
        assert r.status_int == 405

        # test put with _method parameter and POST
        r = app.post('/things/1?_method=put', {'value': 'ONE!'}, status=405)
        assert r.status_int == 405

        # test get delete
        r = app.get('/things/1/delete', status=405)
        assert r.status_int == 405

        # test delete
        r = app.delete('/things/1', status=405)
        assert r.status_int == 405

        # test delete with _method parameter and GET
        r = app.get('/things/1?_method=DELETE', status=405)
        assert r.status_int == 405

        # test delete with _method parameter and POST
        r = app.post('/things/1?_method=DELETE', status=405)
        assert r.status_int == 405

        # test "RESET" custom action
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            r = app.request('/things', method='RESET', status=405)
            assert r.status_int == 405
Ejemplo n.º 59
0
    def test_nested_rest_with_lookup(self):

        class SubController(RestController):

            @expose()
            def get_all(self):
                return "SUB"

        class FinalController(RestController):

            def __init__(self, id_):
                self.id_ = id_

            @expose()
            def get_all(self):
                return "FINAL-%s" % self.id_

            @expose()
            def post(self):
                return "POST-%s" % self.id_

        class LookupController(RestController):

            sub = SubController()

            def __init__(self, id_):
                self.id_ = id_

            @expose()
            def _lookup(self, id_, *remainder):
                return FinalController(id_), remainder

            @expose()
            def get_all(self):
                raise AssertionError("Never Reached")

            @expose()
            def post(self):
                return "POST-LOOKUP-%s" % self.id_

            @expose()
            def put(self, id_):
                return "PUT-LOOKUP-%s-%s" % (self.id_, id_)

            @expose()
            def delete(self, id_):
                return "DELETE-LOOKUP-%s-%s" % (self.id_, id_)

        class FooController(RestController):

            @expose()
            def _lookup(self, id_, *remainder):
                return LookupController(id_), remainder

            @expose()
            def get_one(self, id_):
                return "GET ONE"

            @expose()
            def get_all(self):
                return "INDEX"

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

            @expose()
            def put(self, id_):
                return "PUT-%s" % id_

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

        class RootController(RestController):
            foo = FooController()

        app = TestApp(make_app(RootController()))

        r = app.get('/foo')
        assert r.status_int == 200
        assert r.body == b_('INDEX')

        r = app.post('/foo')
        assert r.status_int == 200
        assert r.body == b_('POST')

        r = app.get('/foo/1')
        assert r.status_int == 200
        assert r.body == b_('GET ONE')

        r = app.post('/foo/1')
        assert r.status_int == 200
        assert r.body == b_('POST-LOOKUP-1')

        r = app.put('/foo/1')
        assert r.status_int == 200
        assert r.body == b_('PUT-1')

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

        r = app.put('/foo/1/2')
        assert r.status_int == 200
        assert r.body == b_('PUT-LOOKUP-1-2')

        r = app.delete('/foo/1/2')
        assert r.status_int == 200
        assert r.body == b_('DELETE-LOOKUP-1-2')

        r = app.get('/foo/1/2')
        assert r.status_int == 200
        assert r.body == b_('FINAL-2')

        r = app.post('/foo/1/2')
        assert r.status_int == 200
        assert r.body == b_('POST-2')
Ejemplo n.º 60
0
    def test_basic_rest(self):

        class OthersController(object):

            @expose()
            def index(self):
                return 'OTHERS'

            @expose()
            def echo(self, value):
                return str(value)

        class ThingsController(RestController):
            data = ['zero', 'one', 'two', 'three']

            _custom_actions = {'count': ['GET'], 'length': ['GET', 'POST']}

            others = OthersController()

            @expose()
            def get_one(self, id):
                return self.data[int(id)]

            @expose('json')
            def get_all(self):
                return dict(items=self.data)

            @expose()
            def length(self, id, value=None):
                length = len(self.data[int(id)])
                if value:
                    length += len(value)
                return str(length)

            @expose()
            def get_count(self):
                return str(len(self.data))

            @expose()
            def new(self):
                return 'NEW'

            @expose()
            def post(self, value):
                self.data.append(value)
                response.status = 302
                return 'CREATED'

            @expose()
            def edit(self, id):
                return 'EDIT %s' % self.data[int(id)]

            @expose()
            def put(self, id, value):
                self.data[int(id)] = value
                return 'UPDATED'

            @expose()
            def get_delete(self, id):
                return 'DELETE %s' % self.data[int(id)]

            @expose()
            def delete(self, id):
                del self.data[int(id)]
                return 'DELETED'

            @expose()
            def reset(self):
                return 'RESET'

            @expose()
            def post_options(self):
                return 'OPTIONS'

            @expose()
            def options(self):
                abort(500)

            @expose()
            def other(self):
                abort(500)

        class RootController(object):
            things = ThingsController()

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

        # test get_all
        r = app.get('/things')
        assert r.status_int == 200
        assert r.body == b_(dumps(dict(items=ThingsController.data)))

        # test get_one
        for i, value in enumerate(ThingsController.data):
            r = app.get('/things/%d' % i)
            assert r.status_int == 200
            assert r.body == b_(value)

        # test post
        r = app.post('/things', {'value': 'four'})
        assert r.status_int == 302
        assert r.body == b_('CREATED')

        # make sure it works
        r = app.get('/things/4')
        assert r.status_int == 200
        assert r.body == b_('four')

        # test edit
        r = app.get('/things/3/edit')
        assert r.status_int == 200
        assert r.body == b_('EDIT three')

        # test put
        r = app.put('/things/4', {'value': 'FOUR'})
        assert r.status_int == 200
        assert r.body == b_('UPDATED')

        # make sure it works
        r = app.get('/things/4')
        assert r.status_int == 200
        assert r.body == b_('FOUR')

        # test put with _method parameter and GET
        r = app.get('/things/4?_method=put', {'value': 'FOUR!'}, status=405)
        assert r.status_int == 405

        # make sure it works
        r = app.get('/things/4')
        assert r.status_int == 200
        assert r.body == b_('FOUR')

        # test put with _method parameter and POST
        r = app.post('/things/4?_method=put', {'value': 'FOUR!'})
        assert r.status_int == 200
        assert r.body == b_('UPDATED')

        # make sure it works
        r = app.get('/things/4')
        assert r.status_int == 200
        assert r.body == b_('FOUR!')

        # test get delete
        r = app.get('/things/4/delete')
        assert r.status_int == 200
        assert r.body == b_('DELETE FOUR!')

        # test delete
        r = app.delete('/things/4')
        assert r.status_int == 200
        assert r.body == b_('DELETED')

        # make sure it works
        r = app.get('/things')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 4

        # test delete with _method parameter and GET
        r = app.get('/things/3?_method=DELETE', status=405)
        assert r.status_int == 405

        # make sure it works
        r = app.get('/things')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 4

        # test delete with _method parameter and POST
        r = app.post('/things/3?_method=DELETE')
        assert r.status_int == 200
        assert r.body == b_('DELETED')

        # make sure it works
        r = app.get('/things')
        assert r.status_int == 200
        assert len(loads(r.body.decode())['items']) == 3

        # test "RESET" custom action
        r = app.request('/things', method='RESET')
        assert r.status_int == 200
        assert r.body == b_('RESET')

        # test "RESET" custom action with _method parameter
        r = app.get('/things?_method=RESET')
        assert r.status_int == 200
        assert r.body == b_('RESET')

        # test the "OPTIONS" custom action
        r = app.request('/things', method='OPTIONS')
        assert r.status_int == 200
        assert r.body == b_('OPTIONS')

        # test the "OPTIONS" custom action with the _method parameter
        r = app.post('/things', {'_method': 'OPTIONS'})
        assert r.status_int == 200
        assert r.body == b_('OPTIONS')

        # test the "other" custom action
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            r = app.request('/things/other', method='MISC', status=405)
            assert r.status_int == 405

        # test the "other" custom action with the _method parameter
        r = app.post('/things/other', {'_method': 'MISC'}, status=405)
        assert r.status_int == 405

        # test the "others" custom action
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            r = app.request('/things/others/', method='MISC')
            assert r.status_int == 200
            assert r.body == b_('OTHERS')

        # test the "others" custom action missing trailing slash
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            r = app.request('/things/others', method='MISC', status=302)
            assert r.status_int == 302

        # test the "others" custom action with the _method parameter
        r = app.get('/things/others/?_method=MISC')
        assert r.status_int == 200
        assert r.body == b_('OTHERS')

        # test an invalid custom action
        r = app.get('/things?_method=BAD', status=405)
        assert r.status_int == 405

        # test custom "GET" request "count"
        r = app.get('/things/count')
        assert r.status_int == 200
        assert r.body == b_('3')

        # test custom "GET" request "length"
        r = app.get('/things/1/length')
        assert r.status_int == 200
        assert r.body == b_(str(len('one')))

        # test custom "GET" request through subcontroller
        r = app.get('/things/others/echo?value=test')
        assert r.status_int == 200
        assert r.body == b_('test')

        # test custom "POST" request "length"
        r = app.post('/things/1/length', {'value': 'test'})
        assert r.status_int == 200
        assert r.body == b_(str(len('onetest')))

        # test custom "POST" request through subcontroller
        r = app.post('/things/others/echo', {'value': 'test'})
        assert r.status_int == 200
        assert r.body == b_('test')