Python TestApp.put_json方法代码示例

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

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

    def test_get_all_tests(self, request):
        self.app.get('/v1/tests')

    def test_get_one_test(self, request):
        self.assertRaises(NotImplementedError,
                          self.app.get,
                          '/v1/tests/1')

    def test_get_all_testsets(self, request):
        self.app.get('/v1/testsets')

    def test_get_one_testset(self, request):
        self.app.get('/v1/testsets/plugin_test')

    def test_get_one_testruns(self, request):
        self.app.get('/v1/testruns/1')

    def test_get_all_testruns(self, request):
        self.app.get('/v1/testruns')

    @patch('ostf_adapter.wsgi.controllers.models')
    def test_post_testruns(self, models, request):
        testruns = [
            {'testset': 'test_simple',
             'metadata': {'cluster_id': 3}
            },
            {'testset': 'test_simple',
             'metadata': {'cluster_id': 4}
            }]
        request.body = json.dumps(testruns)
        models.TestRun.add_test_run.return_value = MagicMock(frontend={})
        self.app.post_json('/v1/testruns', testruns)

    def test_put_testruns(self, request):
        testruns = [
            {'id': 2,
             'metadata': {'cluster_id': 3},
             'status': 'non_exist'
            },
            {'id': 1,
             'metadata': {'cluster_id': 4},
             'status': 'non_exist'
            }]
        request.body = json.dumps(testruns)
        request.storage.get_test_run.return_value = MagicMock(frontend={})
        self.app.put_json('/v1/testruns', testruns)

    def test_get_last_testruns(self, request):
        self.app.get('/v1/testruns/last/101')

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]
class WsgiInterfaceTests(unittest2.TestCase):
    def setUp(self):
        self.app = TestApp(app.setup_app())

    def test_get_all_tests(self, request):
        self.app.get("/v1/tests")

    def test_get_one_test(self, request):
        self.assertRaises(NotImplementedError, self.app.get, "/v1/tests/1")

    def test_get_all_testsets(self, request):
        self.app.get("/v1/testsets")

    def test_get_one_testset(self, request):
        self.app.get("/v1/testsets/plugin_test")

    def test_get_one_testruns(self, request):
        self.app.get("/v1/testruns/1")

    def test_get_all_testruns(self, request):
        self.app.get("/v1/testruns")

    @patch("fuel_plugin.ostf_adapter.wsgi.controllers.models")
    def test_post_testruns(self, models, request):
        testruns = [
            {"testset": "test_simple", "metadata": {"cluster_id": 3}},
            {"testset": "test_simple", "metadata": {"cluster_id": 4}},
        ]
        request.body = json.dumps(testruns)
        models.TestRun.start.return_value = {}
        self.app.post_json("/v1/testruns", testruns)

    def test_put_testruns(self, request):
        testruns = [
            {"id": 2, "metadata": {"cluster_id": 3}, "status": "non_exist"},
            {"id": 1, "metadata": {"cluster_id": 4}, "status": "non_exist"},
        ]
        request.body = json.dumps(testruns)
        request.storage.get_test_run.return_value = MagicMock(frontend={})
        self.app.put_json("/v1/testruns", testruns)

    def test_get_last_testruns(self, request):
        self.app.get("/v1/testruns/last/101")

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

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

    def test_columns(self):
        self.assertEqual(['age', 'id', 'name'], User.columns())

    def _create(self, name=None, age=None):
        return self.app.post_json(build_url(), {'age': age, 'name': name})

    def test_api(self):
        # test post create
        resp = self._create(name='felipe', age=22)
        result = resp.json['result']

        self.assertEqual(result['name'], 'felipe')
        self.assertEqual(result['age'], 22)
        self.assertIsNotNone(result['id'])
        id_created = str(result['id'])

        self._create(name='john', age=26)

        # test get all
        resp = self.app.get(build_url())
        result = resp.json['result']
        self.assertEqual(result[0]['name'], 'felipe')
        self.assertEqual(result[0]['age'], 22)
        self.assertIsNotNone(result[0]['id'])
        self.assertEqual(result[1]['name'], 'john')

        # test get by id
        resp = self.app.get(build_url(id_created))
        result = resp.json['result']
        self.assertEqual('felipe', result['name'])
        self.assertEqual(22, result['age'])

        # test update
        resp = self.app.put_json(build_url(id_created), {'name': 'felipe volpone'})
        self.assertEqual(200, resp.status_int)

        resp = self.app.get(build_url(id_created))
        result = resp.json['result']
        self.assertEqual('felipe volpone', result['name'])
        self.assertEqual(22, result['age'])
        self.assertEqual(int(id_created), result['id'])

        # test delete
        resp = self.app.delete(build_url(id_created))
        self.assertEqual(200, resp.status_int)

        # test get
        resp = self.app.get(build_url(id_created), expect_errors=True)
        self.assertEqual(404, resp.status_int)

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

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

    def testing_wrong_endpoints(self):
        response = self.app.get('/api/', expect_errors=True)
        self.assertEqual(502, response.status_int)

        response = self.app.get('/api/wrongurl', expect_errors=True)
        self.assertEqual(404, response.status_int)

    def __create(self):
        return self.app.post_json('/api/user', {"name": "felipe", "age": 22})

    def test_post(self):
        resp = self.__create()
        result = resp.json
        self.assertEqual('felipe', result['result']['name'])
        self.assertEqual(201, resp.status_int)

    def test_get_all(self):
        self.__create()

        resp = self.app.get('/api/user')
        self.assertEqual(200, resp.status_int)

    def test_get(self):
        uuid_created = '1245'
        resp = self.app.get('/api/user/' + uuid_created)
        self.assertEqual(200, resp.status_int)

    def test_put(self):
        uuid_created = '1245'
        response = self.app.put_json('/api/user/' + uuid_created, {"name": "ray", 'uuid': uuid_created})
        self.assertEqual(200, response.status_int)

    def test_delete(self):
        response = self.app.delete('/api/user/1245')
        self.assertEqual(200, response.status_int)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]

#.........这里部分代码省略.........
    def append_to_queue(self, owner, messageId):
        self.testapp.post_json('/api/v1/messages/%s/queue' % 
                owner, {'id': messageId})

    def test_get_alarms(self):
        for i in range(3):
            self.create_alarm('ed', 'person%s' % i)
        res = self.testapp.get('/api/v1/alarms/ed', status=200)
        self.failUnless(len(res.json) is 3)

    def test_create_alarm(self):
        self.create_alarm('ed', 'creator')
        self.failUnless(len(self.get_alarms('ed')) == 1)

    def test_cancel_alarm(self):
        self.create_alarm('ed', 'person')
        alarm = self.get_alarms('ed')[0]
        self.delete_alarm('ed', alarm['id'])
        self.failUnless(not any(self.get_alarms('ed')))

    def test_get_messages(self):
        self.create_message('ed', 'm1')
        self.failUnless(len(self.get_messages('ed')) == 1)

    def test_get_next_message_when_no_message_in_queue(self):
        try:
            res = self.testapp.get('/api/v1/messages/ed/queue/next')
            error = False
        except:
            error = True
        self.failUnless(error)

    def test_create_message(self):
        self.create_message('ed', 'm1')
        self.failUnless(len(self.get_messages('ed')) == 1)

    def test_delete_message(self):
        m1 = self.create_message('ed', 'm1')
        m2 = self.create_message('ed', 'm2')
        self.delete_message('ed', m1['id'])
        self.failUnless(len(self.get_messages('ed')) == 1)

    def test_get_queue(self):
        m1 = self.create_message('ed', 'm1')
        m2 = self.create_message('ed', 'm2')
        pass

    def test_add_to_queue(self):
        m = [self.create_message('ed', 'm%s' % i) for i in range(3)]
        for msg in m:
            self.add_to_queue('ed', msg['id'], 0)
        nextMsg = self.testapp.get('/api/v1/messages/ed/queue/next').json
        self.failUnless(nextMsg['id'] == 3)

    def test_append_to_queue(self):
        m = [self.create_message('ed', 'm%s' % i) for i in range(3)]
        for msg in m:
            self.append_to_queue('ed', msg['id'])
        queue = self.testapp.get('/api/v1/messages/ed/queue').json
        self.failUnless(queue[0]['id'] == 1 and queue[2]['id'] == 3)

    def test_remove_from_queue(self):
        m = [self.create_message('ed', 'm%s' % i) for i in range(3)]
        for msg in m:
            self.add_to_queue('ed', msg['id'], 0)
        nextMsg = self.testapp.get('/api/v1/messages/ed/queue/next').json
        self.failUnless(nextMsg['id'] == 3)
        self.testapp.delete('/api/v1/messages/ed/queue/0')
        nextMsg = self.testapp.get('/api/v1/messages/ed/queue/next').json
        self.failUnless(nextMsg['id'] == 2)

    def test_mark_as_played(self):
        m1 = self.create_message('ed', 'm1')
        playtime = '2011-04-02 02:45:11'
        self.failUnless(m1['plays'] == [])
        self.testapp.put_json('/api/v1/messages/ed/1/played', {'time_played': playtime})
        m1 = self.get_message('ed', m1['id'])
        self.failUnless(m1['plays'] == [playtime])

    def test_mark_as_unplayed(self):
        m = self.create_message('ed', 'm1')
        playtime = '2011-04-02 02:45:11'
        messages = self.get_messages('ed')
        self.failUnless(not any(messages[0]['plays']))

        self.testapp.put_json('/api/v1/messages/ed/%s/played' % m['id'], {'time_played': playtime})
        messages = self.get_messages('ed')
        self.failUnless(messages[0]['plays'] == [playtime])

        self.testapp.put('/api/v1/messages/ed/%s/unplayed' % m['id'])
        messages = self.get_messages('ed')
        self.failUnless(not any(messages[0]['plays']))

    def test_set_as_default(self):
        m = self.create_message('ed', 'm1')
        messages = self.get_messages('ed')
        self.failUnless(not messages[0]['is_default'])
        self.testapp.put('/api/v1/messages/ed/%s/default' % m['id'])
        messages = self.get_messages('ed')
        self.failUnless(messages[0]['is_default'])

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]
class TestApiViews(unittest.TestCase):
    def setUp(self):
        my_settings = {"sqlalchemy.url": "sqlite:///:memory:", "api_auth_token": u"SECRETAUTHTOKEN"}
        self.config = testing.setUp()
        app = main({}, **my_settings)
        # set up the database
        engine = engine_from_config(my_settings)
        DBSession.configure(bind=engine)
        Base.metadata.create_all(engine)
        with transaction.manager:
            member1 = C3sMember(  # german
                firstname=u"SomeFirstnäme",
                lastname=u"SomeLastnäme",
                email=u"[email protected]",
                address1=u"addr one",
                address2=u"addr two",
                postcode=u"12345",
                city=u"Footown Mäh",
                country=u"Foocountry",
                locale=u"de",
                date_of_birth=date.today(),
                email_is_confirmed=False,
                email_confirm_code=u"ABCDEFGFOO",
                password=u"arandompassword",
                date_of_submission=date.today(),
                membership_type=u"normal",
                member_of_colsoc=True,
                name_of_colsoc=u"GEMA",
                num_shares=u"23",
            )
        DBSession.add(member1)
        member1.email_invite_token_bcgv16 = u"MEMBERS_TOKEN"
        DBSession.flush()

        self.testapp = TestApp(app)

    def tearDown(self):
        testing.tearDown()
        DBSession.close()
        DBSession.remove()

    def test_api_userinfo(self):
        """
        Test the api_userinfo service.

        * must be a PUT, not a GET request
        * the auth header must be present
        * returns None if members refcode does not match
        * returns firstname, lastname, email, membership type
        """
        # try a GET -- must fail
        res = self.testapp.get("/lm", status=405)
        self.assertTrue("405 Method Not Allowed" in res.body)
        self.assertTrue("The method GET is not allowed for this resource." in res.body)

        # try a PUT -- fails under certain conditions
        with self.assertRaises(ValueError):
            res = self.testapp.put("/lm", status=200)
            # ValueError: No JSON object could be decoded

        # try a PUT -- fails under certain conditions
        with self.assertRaises(KeyError):
            res = self.testapp.put_json("/lm", dict(id=1))  # status=200)
            # KeyError: 'token'
        # missing auth token -- must fail
        with self.assertRaises(KeyError):
            res = self.testapp.put_json("/lm", dict(token=1))  # status=200)
            # KeyError: 'HTTP_X_MESSAGING_TOKEN'

        # try false auth token -- must fail: 401 unauthorized
        _headers = {"X-messaging-token": "bar"}
        res = self.testapp.put_json("/lm", dict(token=1), headers=_headers, status=401)

        # now use the correct auth token
        _auth_info = {"X-messaging-token": "SECRETAUTHTOKEN"}

        # ..but a non-existing refcode (email_invite_token_bcgv16)
        # returns no user (None)
        res = self.testapp.put_json("/lm", dict(token="foo"), headers=_auth_info, status=200)
        # body: {"lastname": "None", "firstname": "None"}
        self.assertTrue(json.loads(res.body)["firstname"], "None")
        self.assertTrue(json.loads(res.body)["lastname"], "None")

        self.testapp.reset()

        m1 = C3sMember.get_by_id(1)  # load member from DB for crosscheck

        # now try a valid refcode (email_invite_token_bcgv16)
        res2 = self.testapp.put_json("/lm", dict(token=m1.email_invite_token_bcgv16), headers=_auth_info, status=200)
        self.assertTrue(json.loads(res2.body)["firstname"], m1.firstname)
        self.assertTrue(json.loads(res2.body)["lastname"], m1.lastname)
        self.assertTrue(json.loads(res2.body)["email"], m1.email)
        self.assertTrue(json.loads(res2.body)["mtype"], m1.membership_type)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]
class TestUser(MongoTestRunner):

    def setUp(self):
        self.api = TestApp(webapp.api)
        AppCrawlList([]).save()

    def test_create_user(self):
        user = create_user(self.api)
        user['_id'].should_not.eql(None)

    def test_sing_in_user(self):
        create_user(self.api, provider_id='me', first_name='Ivan')
        user = sign_in_user(self.api, provider_id='me').json
        user['firstName'].should.eql('Ivan')

    def test_add_new_user(self):
        sign_in_user(self.api, provider_id='me',
                status=401).status_int.should.eql(401)
        create_user(self.api, provider_id='me', first_name='Ivan')
        user = sign_in_user(self.api, provider_id='me').json
        user['firstName'].should.eql('Ivan')

    def test_register_user_with_friends(self):
        create_user(self.api, provider_id='id1')
        u = create_user(self.api, friend_ids=['id1'])
        len(u['friends']).should.eql(1)

    def test_user_mutual_friendship(self):
        create_user(self.api, provider_id='id1')
        create_user(self.api, friend_ids=['id1'])
        u = self.api.get('/users/' + 'id1').json
        len(u['friends']).should.eql(1)

    def test_register_user_with_installed_apps(self):
        create_app(self.api, 'com.app.example')
        u = create_user(self.api, installed_apps=['com.app.example'])
        len(u['installed_apps']).should.eql(1)

    def test_update_installed_apps(self):
        create_app(self.api, 'com.example')
        create_user(self.api, provider_id='id1', installed_apps=['com.example'])
        self.api.put_json('/users/' + 'id1' + '/update-app-list', 
                {'installedApps':['com.app']})
        crawl_list = get_crawl_list(self.api)
        crawl_list.should.eql(['com.app'])

    def test_remove_installed_apps_from_recommended(self):

        create_app(self.api, 'test1')
        create_app(self.api, 'test2')
        create_app(self.api, 'test3')
        create_app(self.api, 'test4')
        create_user(self.api, provider_id='me', installed_apps=['test1',
        'test2', 'test3'])
        create_user(self.api, provider_id='u1', installed_apps=['test1',
        'test2'])
        create_user(self.api, provider_id='u2', installed_apps=['test1',
        'test2', 'test3', 'test4'])

        rate_app(self.api, 'me', 'test1', 4.0)
        rate_app(self.api, 'me', 'test2', 4.0)
        rate_app(self.api, 'me', 'test3', 5.0)

        rate_app(self.api, 'u1', 'test1', 3.0)
        rate_app(self.api, 'u1', 'test2', 1.0)

        rate_app(self.api, 'u2', 'test1', 2.5)
        rate_app(self.api, 'u2', 'test2', 5.0)
        rate_app(self.api, 'u2', 'test3', 4.0)
        rate_app(self.api, 'u2', 'test4', 5.0)

        self.api.put_json('/users/' + 'me' + '/update-app-list', 
                {'installedApps':['test4']})
        recommended_apps = self.api.get('/apps/recommend/me').json
        len(recommended_apps).should.eql(0)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]
class UserAPI(unittest.TestCase):
    def setUp(self):
        from service import main
        from paste.deploy import appconfig
        from webtest import TestApp

        # set settings
        os.environ['PYRAMID_SETTINGS'] = 'development.ini#main'
        self.settings = appconfig('config:{}'.format(os.environ['PYRAMID_SETTINGS']), relative_to='.')
        app = main({}, **self.settings)
        self.testapp = TestApp(app)
        self.config = testing.setUp(settings=self.settings)

        self.created = []

    def tearDown(self):
        for obj in self.created:
            obj.delete()

        testing.tearDown()

    def test_user(self):
        response = self.testapp.post_json('/api/v1/users', {}, status=400)

        # create new user
        payload = {
            'email': '[email protected]',
            'password': 'hello',
        }
        response = self.testapp.post_json('/api/v1/users', payload, status=200)
        self.assertTrue(response.json['id'])

        # check duplicate
        response = self.testapp.post_json('/api/v1/users', payload, status=400)

        # check database
        user = User.get_by_email('[email protected]')
        self.assertTrue(user)
        self.created.append(user)

        # get user
        endpoint = '/api/v1/users/{}'.format(user.id)
        response = self.testapp.get(endpoint, status=200)
        self.assertTrue(response.json['id'])

        # update user
        payload = {
            'active': True,
            'email': '[email protected]',
        }
        endpoint = '/api/v1/users/{}'.format(user.id)
        response = self.testapp.put_json(endpoint, payload, status=200)
        user = User.get_by_id(user.id)
        self.assertTrue(user.active)

        # change password
        payload = {
            'password': 'world',
        }
        endpoint = '/api/v1/users/{}/password'.format(user.id)
        response = self.testapp.put_json(endpoint, payload, status=200)
        user = User.authenticate_user('[email protected]', 'world')
        self.assertTrue(user)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]

#.........这里部分代码省略.........

        returned_time = resp.json_body['time']

        # we didn't specify any other fields in the endpoint definition,
        # so this one should only get the defaults
        expected_fields = DateTimeResource._default_fields

        self.assertExpectedFields(returned_time, expected_fields)

        self.assertIn('Cache-Control', resp.headers)
        self.assertEqual('max-age=3', resp.headers['Cache-Control'])


    def test_successful_json_post_with_required_params(self):
        # this is the same as the above post, but passes json in the
        # request body, instead of x-www-form-urlencoded
        resp = self.app.post_json('/api/time/parse', {'month': 2})

        self.assertEqual(resp.status_code, 200)
        self.assertIn('time', resp.json_body)

        returned_time = resp.json_body['time']

        # we didn't specify any other fields in the endpoint definition,
        # so this one should only get the defaults
        expected_fields = DateTimeResource._default_fields

        self.assertExpectedFields(returned_time, expected_fields)


    def test_unsuccessful_post_missing_required_params(self):
        resp = self.app.post('/api/time/parse', status=422)

        self.assertIn('error', resp.json_body)


    def test_getting_with_nested_resources(self):
        test_duration = 60 * 1000 # one minute in milliseconds
        resp = self.app.get('/api/time/range', {'duration': test_duration})

        self.assertEqual(resp.status_code, 200)
        self.assertIn('range', resp.json_body)

        returned_range = resp.json_body['range']
        self.assertEqual(returned_range['duration_microseconds'],
                test_duration * 1000)

        # start has default fields
        start = returned_range['start']
        expected_fields = DateTimeResource._default_fields
        self.assertExpectedFields(start, expected_fields)

        # end has all of them
        end = returned_range['end']
        expected_fields = DateTimeResource._all_fields()
        self.assertExpectedFields(end, expected_fields)

    def test_resource(self):

        # Start by resetting the resource.
        # (multiple test runs from the same process will fail otherwise)
        resp = self.app.post('/api/resource/reset')
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content_type, 'application/json')
        self.assertEqual(resp.json, {'key': 'value'})

        # Test creating a new resource
        resp = self.app.put_json('/api/resource', {'key': 'boop'},
            headers={'Content-Type': 'application/json'})
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content_type, 'application/json')
        self.assertEqual(resp.json, {'key': 'boop'})

        # Test retrieving the resource.
        resp = self.app.get('/api/resource')
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content_type, 'application/json')
        self.assertEqual(resp.json, {'key': 'boop'})

        # Test patching the resource.
        # Without the correct Content-Type, we expect a 415 error.
        self.assertRaises(AppError, self.app.patch_json,
            '/api/resource', {'key': 'value2'})

        resp = self.app.patch_json('/api/resource', {'key': 'value2'},
            headers={'Content-Type': 'application/merge-patch+json'})
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content_type, 'application/json')
        self.assertEqual(resp.json, {'key': 'value2'})

        # Test get to ensure the resource persists.
        resp = self.app.get('/api/resource')
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.content_type, 'application/json')
        self.assertEqual(resp.json, {'key': 'value2'})

        # A NoContentResource shouldn't have a Content-Type header (no content!)
        resp = self.app.post('/api/blank')
        self.assertEqual(resp.status_code, 204)
        self.assertEqual(resp.content_type, None)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]
class AppUser:
    """:class:`webtest.TestApp` wrapper for backend functional testing."""

    def __init__(self, app,
                 rest_url: str='http://localhost',
                 base_path: str='/',
                 header: dict=None):
        """Initialize self."""
        self.app = TestApp(app)
        """:class:`webtest.TestApp`to send requests to the backend server."""
        self.rest_url = rest_url
        """backend server url to generate request urls."""
        self.base_path = base_path
        """path prefix to generate request urls."""
        self.header = header or {}
        """default header for requests, mostly for authentication."""
        self._resolver = DottedNameResolver()

    def post_resource(self, path: str,
                      iresource: IInterface,
                      cstruct: dict) -> TestResponse:
        """Build and post request to create a new resource."""
        url = self._build_url(path)
        props = self._build_post_body(iresource, cstruct)
        resp = self.app.post_json(url, props, headers=self.header,
                                  expect_errors=True)
        return resp

    def put(self, path: str, cstruct: dict={}) -> TestResponse:
        """Put request to modify a resource."""
        url = self._build_url(path)
        resp = self.app.put_json(url, cstruct, headers=self.header,
                                 expect_errors=True)
        return resp

    def post(self, path: str, cstruct: dict={}) -> TestResponse:
        """Post request to create a new resource."""
        url = self._build_url(path)
        resp = self.app.post_json(url, cstruct, headers=self.header,
                                  expect_errors=True)
        return resp

    def _build_post_body(self, iresource: IInterface, cstruct: dict) -> dict:
        return {'content_type': iresource.__identifier__,
                'data': cstruct}

    def _build_url(self, path: str) -> str:
        if path.startswith('http'):
            return path
        return self.rest_url + self.base_path + path

    def batch(self, subrequests: list):
        """Build and post batch request to the backend rest server."""
        resp = self.app.post_json(batch_url, subrequests, headers=self.header,
                                  expect_errors=True)
        return resp

    def get(self, path: str, params={}) -> TestResponse:
        """Send get request to the backend rest server."""
        url = self._build_url(path)
        resp = self.app.get(url,
                            headers=self.header,
                            params=params,
                            expect_errors=True)
        return resp

    def options(self, path: str) -> TestResponse:
        """Send options request to the backend rest server."""
        url = self._build_url(path)
        resp = self.app.options(url, headers=self.header, expect_errors=True)
        return resp

    def get_postable_types(self, path: str) -> []:
        """Send options request and return the postable content types."""
        resp = self.options(path)
        if 'POST' not in resp.json:
            return []
        post_request_body = resp.json['POST']['request_body']
        type_names = sorted([r['content_type'] for r in post_request_body])
        iresources = [self._resolver.resolve(t) for t in type_names]
        return iresources

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


    def setUp(self):
        from nokkhumapi import main

        cfg = configparser.ConfigParser()
        cfg.read('../../../development.ini')

        settings = dict(cfg.items('app:main'))

        app = main({}, **settings)
        from webtest import TestApp
        self.testapp = TestApp(app)

        args = dict(password_credentials={"email": "[email protected]",
                                          "password": "password"}
                    )
        response = self.testapp.post_json('/authentication/tokens', params=args, status=200)
        print("authentication: ")

        self.pp = pprint.PrettyPrinter(indent=4)
        self.pp.pprint(response.json)

        self.token = response.json['access']['token']['id']

        self.project_id = 1

    def tearDown(self):
        pass


    def test_projectview_can_push_data_to_database(self):

        args=dict(
                  name = 'Test Project',
                  description = '',
                  status = 'active',
                  user = {"id":1}
                )
        response = self.testapp.post_json('/projects', params={'project':args}, headers=[('X-Auth-Token', self.token)], status=200)
        print("responce post :")
        self.pp.pprint(response.json)
        
        self.assertIn("id",response.json["project"])
        
        self.project_id = response.json["project"]["id"]
        
        #retrieve project via project id
        response = self.testapp.get('/projects/%d'%self.project_id, headers=[('X-Auth-Token', self.token)], status = 200)
        print("response get")
        self.pp.pprint(response.json)
        
        self.assertEqual(response.json["project"]["id"], self.project_id)
        self.project_dict =  response.json["project"]
        
        #try to change name
        self.project_dict['status'] = 'Delete'
        args = self.project_dict
        
        response = self.testapp.put_json('/projects/%d'%response.json["project"]["id"], params={'project':args}, headers=[('X-Auth-Token', self.token)], status=200)
        print("response update: ")
        self.pp.pprint(response.json)
        
        self.assertIn("id", response.json["project"])
        
        response = self.testapp.delete('/projects/%d'%response.json["project"]["id"], headers=[('X-Auth-Token', self.token)], status=200)
        print("response delete: ")
        self.pp.pprint(response.json)

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

    def setUp(self):
        database.drop_tables([User], safe=True)
        database.create_tables([User])

        self.app = TestApp(application)

    def test_columns(self):
        self.assertEqual(['age', 'id', 'name'], User.columns())

    def test_to_instance(self):
        new_user = User.to_instance({'age': 99, 'name': 'Frank Sinatra'})
        self.assertEqual(99, new_user.age)
        self.assertEqual('Frank Sinatra', new_user.name)

    def test_database_methods(self):
        User.create(name='felipe', age=100)

    def _create(self, name=None, age=None):
        return self.app.post_json(build_url(), {'age': age, 'name': name})

    def test_api(self):
        # test post create
        resp = self._create(name='felipe', age=22)
        result = resp.json['result']
        self.assertEqual(result['name'], 'felipe')
        self.assertEqual(result['age'], 22)
        self.assertIsNotNone(result['id'])
        id_created = str(result['id'])

        self._create(name='john', age=26)

        # test get all
        resp = self.app.get(build_url())
        result = resp.json['result']

        self.assertEqual(result[0]['name'], 'felipe')
        self.assertEqual(result[0]['age'], 22)
        self.assertIsNotNone(result[0]['id'])
        self.assertEqual(result[1]['name'], 'john')

        # test get by id
        resp = self.app.get(build_url(id_created))
        result = resp.json['result']
        self.assertEqual('felipe', result['name'])
        self.assertEqual(22, result['age'])

        # test update
        resp = self.app.put_json(build_url(id_created), {'name': 'felipe volpone'})
        self.assertEqual(200, resp.status_int)

        # testing if update worked
        resp = self.app.get(build_url(id_created))
        result = resp.json['result']
        self.assertEqual('felipe volpone', result['name'])
        self.assertEqual(22, result['age'])
        self.assertEqual(int(id_created), result['id'])

        # test delete
        resp = self.app.delete(build_url(id_created))
        self.assertEqual(200, resp.status_int)

        # test get
        resp = self.app.get(build_url(id_created), expect_errors=True)
        self.assertEqual(404, resp.status_int)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]
class Actualizacion(TestCase):
    """
    NOTA: Sobre la validación de datos, testar directamente nuestra pequeña clase 
    TODO: Validar cambio de grupo principal
    TODO: Validar cambio de estado de la cuenta
    TODO: Validar cambios de grupos
    TODO: Validar cambio de contraseña
    """

    @classmethod
    def setUpClass(self):

        # Cargamos los datos
        entidad = cargar_datos('usuario')[2]
        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_actualizacion(self):
        self.datos['corpus']['title'] = "Titulador"
        
        self.testapp.put_json('/usuarios/' + self.uid, status=200, params=self.datos, headers=self.token)
        
        res = self.testapp.get('/usuarios/' + self.uid, status=200, headers=self.token)
        respuesta = res.json_body['mensaje'][0]['title']
        datos = self.datos['corpus']['title']
        
        self.assertEqual(respuesta, datos)

    def test_actualizacion_displayName(self):
        sn = "Sotomayor"
        givenName = self.datos['corpus']['givenName']
        displayName = givenName + " " + sn 
        
        self.datos['corpus']['sn'] = sn
        self.testapp.put_json('/usuarios/' + self.uid, status=200, params=self.datos, headers=self.token)
        
        res = self.testapp.get('/usuarios/' + self.uid, status=200, headers=self.token)
        respuesta = res.json_body['mensaje'][0]['displayName']
        
        self.assertEqual(respuesta, displayName)

    def test_uid_no_coincide_parametros_url(self):
        uid = 'fitzcarraldo'
        
        self.testapp.put_json('/usuarios/' + uid, status=400, params=self.datos, headers=self.token)

    def test_corpus_faltante(self):
        datos = {'cuerpo': self.datos['corpus'].copy()}
        
        self.testapp.put_json('/usuarios/' + self.uid, status=400, params=datos, headers=self.token)
    
    def test_json_malformateado(self):
        datos = "Mínimo esfuerzo para máximo daño"
        self.testapp.put_json('/usuarios/' + self.uid, status=400, params=datos, headers=self.token)
    
    def test_noexistente(self):
        uid = 'fitzcarraldo'
        datos = {'corpus': self.datos['corpus'].copy()}
        datos['corpus']['uid'] = uid
        
        self.testapp.put_json('/usuarios/' + uid, status=404, params=datos, headers=self.token)

    def test_claves_incompletas(self):
        cuerpo = self.datos['corpus'].copy()
        del cuerpo['sn']
        del cuerpo['givenName']
        datos = {'corpus': cuerpo}
        
        self.testapp.put_json('/usuarios/' + self.uid, status=400, params=datos, headers=self.token)

    def test_actualizacion_noauth(self):
        self.testapp.put_json('/usuarios/' + self.uid, status=403, params=self.datos)

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

    def setUp(self):
        from .. import main
        settings = {'mongodb.db_name': 'nokkhum', 
                    'mongodb.host': 'localhost',
                    'nokkhum.auth.secret': 'nokkhum'}
        app = main({}, **settings)
        from webtest import TestApp
        self.testapp = TestApp(app)
        
        args = dict(password_credentials= {"email": "[email protected]", 
                                          "password": "password"}
                    )
        response = self.testapp.post_json('/authentication/tokens', params=args, status=200)
        print("authentication: ")
        
        self.pp=pprint.PrettyPrinter(indent=4)
        self.pp.pprint(response.json)
        
        self.token = response.json['access']['token']['id']
    
    def test_cameraview_can_push_data_to_database(self):
        pp = pprint.PrettyPrinter(indent=4)
        
        # create camera
        args = dict(username='admin',
                     password='123456', 
                     name='ierk hamham',
                     host="127.0.0.1",
                     port=8080,
                     url='', 
                     image_size='', 
                     fps=5, 
                     storage_periods=1,
                     project    = dict(id = 1),
                     user       = dict(id = 1),
                     model      = dict(id = '5113b19c698a974f3ee2f69e'),
                     )
        
        print("args: ")
        pp.pprint(args)
        response = self.testapp.post_json('/cameras', params={'camera':args}, headers=[('X-Auth-Token', self.token)], status=200)
        print("response create: ")
        pp.pprint(response.json)
        
        self.assertIn("id", response.json["camera"])

        self.camera_id = response.json["camera"]["id"]

        # retrieve camera via camera id
        response = self.testapp.get('/cameras/%d'%self.camera_id, headers=[('X-Auth-Token', self.token)], status=200)
        print( "response get: ")
        pp.pprint(response.json)
        
        self.assertEqual(response.json["camera"]["id"], self.camera_id)
        self.camera_dict =  response.json["camera"]
        
#        # try to change name
        args = self.camera_dict
        args["name"] = '123'
        args["host"] = '172.30.23.2'
        response = self.testapp.put_json('/cameras/1', params={'camera':args},headers=[('X-Auth-Token', self.token)], status=200)
        print("response update: ") 
        pp.pprint( response.json)

# 需要导入模块: from webtest import TestApp [as 别名]
# 或者: from webtest.TestApp import put_json [as 别名]

#.........这里部分代码省略.........
        # Logout without login
        res = self.testapp.get("/logout")
        self.failUnless(res.status == "302 Found")
        res = res.follow()
        self.failUnless(res.request.url == "http://localhost/")

    def test_api_items_get(self):
        self._login()
        res = self.testapp.get("/api/items")
        json = res.json
        self.failUnless(len(json) > 0)
        _id = json[0].get("_id")
        res = self.testapp.get("/api/items/{0}".format(_id))
        self.failUnless(str(res.json.get("_id")) == str(_id))

    def test_api_assets_get(self):
        self._login()
        res = self.testapp.get("/api/assets")
        json = res.json
        self.failUnless(len(json) > 0)
        object_id = json[0].get("_id")
        short_id = json[0].get("id")
        res = self.testapp.get("/api/assets/{0}".format(object_id))
        self.failUnless(str(res.json.get("_id")) == str(object_id))

        res = self.testapp.get("/api/assets/{0}".format(short_id))
        self.failUnless(str(res.json.get("id")) == str(short_id))

        self.failUnless(len(res.json.keys()) > 2)

    def test_api_items_put_valid(self):
        self._login()
        res = self.testapp.get("/api/items")
        json = res.json
        self.failUnless(len(json) > 0)
        object_id = json[0].get("_id")
        params = dict(_id=object_id, listIndex=0, type="lesson", title="something or other", desc="Nothing", text="")
        self.testapp.put_json("/api/items/{0}".format(object_id), params=params)

    def test_api_items_put_invalid(self):
        self._login()
        res = self.testapp.get("/api/items")
        json = res.json
        self.failUnless(len(json) > 0)
        object_id = json[0].get("_id")
        # First test non-json put
        params = dict(_id=object_id, listIndex=0, type="lesson", title="something or other", desc="Nothing", text="")
        # Should return 406 Not Acceptable
        self.testapp.put("/api/items/{0}".format(object_id), params=params, status=406)

        # Test a request with no _id supplied
        params = dict(listIndex=0, type="lesson", title="something or other", desc="Nothing", text="")
        # Should return 503
        self.testapp.put_json("/api/items/{0}".format(object_id), params=params, status=503)

    def test_api_assets_get_invalid_id(self):
        # self._login()
        self.testapp.get('/api/assets/#[email protected]"()/[]}{+?\\&`', status=404)

    def test_misaka_post(self):
        import random
        import string

        char_list = string.letters + string.digits
        random_markdown = ""
        for i in range(100):
            random_markdown += random.choice(char_list)
        params = {
            "md": (
                r"$ \alpha = \beta $"  # Math syntax
                r"$ \alpha = \beta $"  # Image cache hit
                r"$ {} $"  # To ensure a cache miss
                "## Random heading"  # Normal markdown
                "![Alt text goes here](id=4d)"  # Image tags
                "![Alt text](id=nonexistant)"
            ).format(random_markdown)
        }
        self.testapp.post("/misaka", params=params, status=403)
        self._login()
        self.testapp.post("/misaka", params=params)

    def test_get_asset_thumb_image_valid_id(self):
        self._login()
        res = self.testapp.get("/api/assets")
        json = res.json
        short_id = json[0].get("id")
        res = self.testapp.get("/api/assets/{id}/thumb".format(id=short_id), status=303)
        self.failUnless("rackcdn.com" in res)

        res = self.testapp.get("/api/assets/{id}/image".format(id=short_id), status=303)
        self.failUnless("rackcdn.com" in res)
        # res.showbrowser()

    def test_api_item_get_not_logged_in(self):
        self.testapp.reset()
        self.testapp.get("/api/items", status=403)

    def test_api_asset_get_not_logged_in(self):
        self.testapp.reset()
        self.testapp.get("/api/assets", status=403)