Esempio n. 1
0
    def test_webapp_publish(self):

        # tornado does not support windows (yet)
        self.thisHostMustNot(platform='windows')
        foo = Foo()

        wapp = s_webapp.WebApp()
        wapp.listen(0, host='127.0.0.1')
        wapp.addApiPath('/v1/horked', foo.horked)
        wapp.addApiPath('/v1/addup/([0-9]+)', foo.addup)

        client = AsyncHTTPClient(self.io_loop)
        port = wapp.getServBinds()[0][1]
        resp = yield client.fetch('http://127.0.0.1:%d/v1/addup/30?y=40' %
                                  port)
        resp = json.loads(resp.body.decode('utf-8'))

        self.assertEqual(resp.get('ret'), 70)
        self.assertEqual(resp.get('status'), 'ok')

        resp = yield client.fetch('http://127.0.0.1:%d/v1/addup/20' % port)
        resp = json.loads(resp.body.decode('utf-8'))

        self.assertEqual(resp.get('ret'), 20)
        self.assertEqual(resp.get('status'), 'ok')

        resp = yield client.fetch('http://127.0.0.1:%d/v1/horked' % port)
        resp = json.loads(resp.body.decode('utf-8'))

        self.assertEqual(resp.get('err'), 'Horked')
        self.assertEqual(resp.get('status'), 'err')

        wapp.fini()
Esempio n. 2
0
    def test_webapp_body(self):

        # python requests module has windows bug?!?!?
        self.thisHostMustNot(platform='windows')

        class Haha:
            def bar(self, hehe, body=None):
                return (hehe,body.decode('utf8'))

        haha = Haha()

        wapp = s_webapp.WebApp()
        wapp.listen(0, host='127.0.0.1')
        wapp.addApiPath('/v1/haha/bar/([a-z]+)', haha.bar)

        client = AsyncHTTPClient(self.io_loop)
        port = wapp.getServBinds()[0][1]

        headers={'Content-Type': 'application/octet-stream'}

        resp = yield client.fetch('http://127.0.0.1:%d/v1/haha/bar/visi' % port, headers=headers, body='GRONK', allow_nonstandard_methods=True)
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual( tuple(resp.get('ret')), ('visi','GRONK') )

        resp = yield client.fetch('http://127.0.0.1:%d/v1/haha/bar/visi' % port, method='POST', headers=headers, body='GRONK')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual( tuple(resp.get('ret')), ('visi','GRONK') )

        wapp.fini()
Esempio n. 3
0
    def test_webapp_body(self):

        class Haha:
            def bar(self, hehe, body=None):
                return (hehe,body.decode('utf8'))

        haha = Haha()

        wapp = s_webapp.WebApp()
        wapp.listen(0, host='127.0.0.1')
        wapp.addApiPath('/v1/haha/bar/([a-z]+)', haha.bar)

        client = AsyncHTTPClient(self.io_loop)
        port = wapp.getServBinds()[0][1]

        headers={'Content-Type': 'application/octet-stream'}

        resp = yield client.fetch('http://127.0.0.1:%d/v1/haha/bar/visi' % port, headers=headers, body='GRONK', allow_nonstandard_methods=True)
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual( tuple(resp.get('ret')), ('visi','GRONK') )

        resp = yield client.fetch('http://127.0.0.1:%d/v1/haha/bar/visi' % port, method='POST', headers=headers, body='GRONK')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual( tuple(resp.get('ret')), ('visi','GRONK') )

        wapp.fini()
Esempio n. 4
0
    def test_webapp_publish(self):

        # tornado does not support windows (yet)
        self.thisHostMustNot(platform='windows')
        foo = Foo()

        wapp = s_webapp.WebApp()
        wapp.listen(0, host='127.0.0.1')
        wapp.addApiPath('/v1/horked', foo.horked )
        wapp.addApiPath('/v1/addup/([0-9]+)', foo.addup )

        client = AsyncHTTPClient(self.io_loop)
        port = wapp.getServBinds()[0][1]
        resp = yield client.fetch('http://127.0.0.1:%d/v1/addup/30?y=40' % port)
        resp = json.loads(resp.body.decode('utf-8'))

        self.assertEqual( resp.get('ret'), 70 )
        self.assertEqual( resp.get('status'), 'ok' )

        resp = yield client.fetch('http://127.0.0.1:%d/v1/addup/20' % port)
        resp = json.loads(resp.body.decode('utf-8'))

        self.assertEqual( resp.get('ret'), 20 )
        self.assertEqual( resp.get('status'), 'ok' )

        resp = yield client.fetch('http://127.0.0.1:%d/v1/horked' % port)
        resp = json.loads(resp.body.decode('utf-8'))

        self.assertEqual( resp.get('err'), 'Horked' )
        self.assertEqual( resp.get('status'), 'err' )

        wapp.fini()
Esempio n. 5
0
    def test_customer_data(self):
        """Call the '/customer' endpoint and test that the output and database.
        Verifies that the output can be parsed as JSON.
        """
        client = AsyncHTTPClient(self.io_loop)

        # First load the database with sample orders to ensure the customer
        # exists.
        response = yield client.fetch(
            "http://*****:*****@example.com',
                'total': 100.80}))
        self.assertEqual(response.code, 200)
        # Decode bytes into utf-8 string and parse the JSON
        data = json.loads(response.body.decode('utf-8'))
        self.assertEqual(100, data["reward_points"])
        self.assertEqual("A", data["reward_tier"])
        self.assertEqual("5% off purchase", data["reward_tier_name"])
        self.assertEqual("10% off purchase", data["next_reward_tier_name"])
        self.assertEqual("B", data["next_reward_tier"])
        self.assertEqual(0.0, data["next_reward_tier_progress"])
        self.assertEqual("*****@*****.**", data["email_address"])

        response = yield client.fetch(
            "http://*****:*****@example.com',
                'total': 50}))
        self.assertEqual(response.code, 200)
        # Decode bytes into utf-8 string and parse the JSON
        data = json.loads(response.body.decode('utf-8'))
        self.assertEqual(150, data["reward_points"])
        self.assertEqual("A", data["reward_tier"])
        self.assertEqual("5% off purchase", data["reward_tier_name"])
        self.assertEqual("10% off purchase", data["next_reward_tier_name"])
        self.assertEqual("B", data["next_reward_tier"])
        self.assertEqual(0.5, data["next_reward_tier_progress"])
        self.assertEqual("*****@*****.**", data["email_address"])

        # Call the customer endpoint to verify
        response = yield client.fetch(
            "http://*****:*****@example.com'}))
        self.assertEqual(response.code, 200)
        # Decode bytes into utf-8 string and parse the JSON
        data = json.loads(response.body.decode('utf-8'))
        print("Data: {}".format(data))
        self.assertEqual(150, data["reward_points"])
        self.assertEqual("A", data["reward_tier"])
        self.assertEqual("5% off purchase", data["reward_tier_name"])
        self.assertEqual("10% off purchase", data["next_reward_tier_name"])
        self.assertEqual("B", data["next_reward_tier"])
        self.assertEqual(0.5, data["next_reward_tier_progress"])
        self.assertEqual("*****@*****.**", data["email_address"])
 def test_register(self):
     testDict = {
         'name': 'loki',
         'phone': 'killll',
         'email': 'saerty@34',
         'password': '******'
     }
     client = AsyncHTTPClient()
     client.fetch()
Esempio n. 7
0
 def test_customer_accessible(self):
     """Call the '/customer' endpoint to verify the web server is running"""
     client = AsyncHTTPClient(self.io_loop)
     response = yield client.fetch("http://*****:*****@example.com'}))
     self.assertEqual(response.code, 200)
Esempio n. 8
0
    def test_invalid_model(self):
        self.thisHostMustNot(platform='windows')
        client = AsyncHTTPClient(self.io_loop)

        with self.assertRaises(HTTPError) as context:
            yield client.fetch(self.host + '/v1/horked')
        self.assertEqual(context.exception.code, 404)
Esempio n. 9
0
    def test_get_with_bad_query(self):
        client = AsyncHTTPClient()

        query = "limit=-5&offset=qwe&order=1&order_by=1"

        response = yield client.fetch(
            "http://localhost:9090/post?{}".format(query))
        self.assertIn(response.code, (200, 201))
Esempio n. 10
0
	def test_idea_add(self):
		#Add
		client = AsyncHTTPClient(self.io_loop)
		
		resp = yield client.fetch(IDEA_URL)

		print resp.body
		self.assertIn("", resp.body)
Esempio n. 11
0
        def do_login():

            client = AsyncHTTPClient(self.io_loop)
            #examlpe url: /mr.login?message=<message in JSON>&other_data_for_the_query_string=value
            url = self.get_url('/mr.login?message=' + urllib.parse.quote(json.dumps(message0)))

            response = yield client.fetch(url, method='GET')

            self.assertEqual(response.code, 200)
Esempio n. 12
0
    def test_get_weather(self):
        client = AsyncHTTPClient()
        # first check to see we get a bad response when no city id passed
        try:
            response = yield client.fetch("http://localhost:3000/get_weather")
            # should never reach here but if it does,
            # the code should not be 200 (all good response)
            self.assertNotEqual(200, response.code)
        # expect a 400 error response
        except httpclient.HTTPClientError:
            # we got it so ignore it
            pass
        # try again, this time with a city ID
        response = yield client.fetch(
            "http://localhost:3000/get_weather?city_id=6173331")
        self.assertEqual(200, response.code)
        weather_info = json.loads(response.body)

        # loop all weather updates in the response object
        # ensure each object has the keys the app will look for
        for update in weather_info:
            self.assertIn("weather", update)
            # ensure there is at least 1 weather object
            self.assertTrue(len(update['weather']) > 0)
            self.assertIn("main", update['weather'][0])
            self.assertIn("icon", update['weather'][0])
            self.assertIn("description", update['weather'][0])

            self.assertIn("main", update)
            self.assertIn("temp", update['main'])
            self.assertIn("humidity", update['main'])

            # test the date string
            self.assertIn("dt_txt", update)
            # should look like YYYY-MM-DD HH:MM:SS
            try:
                date_object = datetime.datetime.strptime(
                    update['dt_txt'], "%Y-%m-%d %H:%M:%S")
            except ValueError:
                self.fail('date string format incorrect. %s '
                          'does not match YYYY-MM-DD HH:MM:SS' %
                          update['dt_txt'])

            self.assertTrue(isinstance(date_object, datetime.datetime))
Esempio n. 13
0
    def test_get_with_query(self):
        client = AsyncHTTPClient()

        query = "limit=7&offset=1&order=title&order_by=desc"

        response = yield client.fetch(
            "http://localhost:9090/post?{}".format(query))
        self.assertIn(response.code, (200, 201))
        self.assertIn(len(self.get_body(response.body)), (7, ),
                      msg='response len != set limit in query')
Esempio n. 14
0
        def do_login():

            client = AsyncHTTPClient(self.io_loop)
            #examlpe url: /mr.login?message=<message in JSON>&other_data_for_the_query_string=value
            url = self.get_url('/mr.login?message=' +
                               urllib.parse.quote(json.dumps(message0)))

            response = yield client.fetch(url, method='GET')

            self.assertEqual(response.code, 200)
Esempio n. 15
0
 def runTest(self):
     """Ensure our mocking of AsyncHTTPClient functions
     """
     client = AsyncHTTPClient()
     with mock.patch.object(client, 'fetch') as fetch_mock:
         static_body = 'hello'
         static_response_code = 999
         _setup_fetch(fetch_mock, static_response_code, static_body)
         response = yield client.fetch('http://example.com')
         self.assertEqual(response.code, static_response_code)
         self.assertEqual(response.body, static_body)
Esempio n. 16
0
    def test_del(self):
        post_data = {
            'user_info': json_encode(user_info),
            'module': 'yum',
            'host': host,
            'package_name': package,
            'state': 'absent'
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL, method='POST', body=json_encode(post_data))
        print(response.body)
Esempio n. 17
0
    def test_shell(self):
        post_data = {
            'user_info': json_encode(user_info),
            'host': host,
            'module': 'shell',
            'args': 'yum list installed |grep httpd',
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 18
0
    def test_crud_multi(self):
        self.thisHostMustNot(platform='windows')
        client = AsyncHTTPClient(self.io_loop)

        # Can we create tufos?
        tufo = {}
        for i in range(2):
            i = str(i)
            data = json.dumps({'bar': i, 'key' + i: 'val' + i})
            resp = yield client.fetch(self.host + '/v1/bar', method='POST', body=data, headers={'Content-Type': 'application/json'})
            resp = json.loads(resp.body.decode('utf-8'))
            self.assertEqual(resp['status'], 'ok')
            self.assertDictMust(resp['ret'][1], {'bar': i, 'bar:bar': i, 'bar:key' + i: 'val' + i, 'tufo:form': 'bar',})
            tufo[resp['ret'][0]] = resp['ret'][1]

        # Do they persist?
        resp = yield client.fetch(self.host + '/v1/bar')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        self.assertEqual(len(resp['ret']), len(tufo))
        for rslt in resp['ret']:
            self.assertDictMust(tufo[rslt[0]],rslt[1])

        # Can we get a subset?
        resp = yield client.fetch(self.host + '/v1/bar?prop=bar:key1&value=val1')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        self.assertEqual(len(resp['ret']), 1)
        for rslt in resp['ret']:
            self.assertDictMust(tufo[rslt[0]],rslt[1])
            self.assertEqual(rslt[1]['bar:key1'], 'val1')

        # Can we delete a subset?
        resp = yield client.fetch(self.host + '/v1/bar?prop=bar:key1&value=val1', method='DELETE')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')

        resp = yield client.fetch(self.host + '/v1/bar')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        self.assertEqual(len(resp['ret']), 1)
        for rslt in resp['ret']:
            self.assertDictMust(tufo[rslt[0]], rslt[1])
            self.assertEqual(rslt[1]['bar:key0'], 'val0')

        # Can they be deleted?
        resp = yield client.fetch(self.host + '/v1/bar', method='DELETE')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')

        resp = yield client.fetch(self.host + '/v1/bar')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        self.assertEqual(resp['ret'], [])
Esempio n. 19
0
    def test_systemd(self):
        post_data = {
            'module': 'systemd',
            'name': 'httpd',
            'state': 'restarted',
            'host': host
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 20
0
    def test_hostname(self):
        post_data = {
            'user_info': json_encode(user_info),
            'host': host,
            'host_name': '12ff3',
            'module': 'hostname'
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 21
0
 def test_customer_not_exist(self):
     """Call the '/customer' endpoint and test that the output and database.
     Verifies that the output can be parsed as JSON.
     """
     client = AsyncHTTPClient(self.io_loop)
     response = yield client.fetch("http://*****:*****@example.com'}))
     self.assertEqual(response.code, 200)
     data = json.loads(response.body.decode('utf-8'))
     self.assertEqual("CustomerNotFoundError", data[0]["error"])
     self.assertIn(
         "The customer with email '*****@*****.**' was not found in the database.",
         data[0]["detail"])
Esempio n. 22
0
    def test_add(self):
        post_data = {
            'module': 'copy',
            'file_name': 'test',
            'host': host,
            'content': 'test',
            'dest': '/root/1',
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 23
0
    def test_del_user(self):
        post_data = {
            'user_info': json_encode(user_info),
            'host': host,
            'module': 'user',
            'state': 'present',
            'name': 'test2',
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 24
0
 def test_order_error(self):
     """Call the '/order' endpoint and test that the output and database.
     Verifies that the output can be parsed as JSON.
     """
     client = AsyncHTTPClient(self.io_loop)
     response = yield client.fetch("http://localhost:7050/order",
                                   method='POST',
                                   body=urlencode({}))
     self.assertEqual(response.code, 200)
     data = json.loads(response.body.decode('utf-8'))
     self.assertEqual("MissingArgumentError", data[0]["error"])
     self.assertEqual("MissingArgumentError", data[1]["error"])
     self.assertIn("' was not included in the message.", data[0]["detail"])
     self.assertIn("' was not included in the message.", data[1]["detail"])
    def test_fetch(self):
        dir = os.path.dirname(os.path.realpath(__file__))

        with open('{}/config.yaml'.format(dir), 'r') as stream:
            config = yaml.load(stream)
            self.base_url = config['base_url']

        connect_db(self.io_loop)

        Branch.objects.limit(1).find_all(callback=self.stop)
        branch = self.wait()

        request = HTTPRequest('{}/api/request_token'.format(self.base_url),
                              headers={
                                  'ES-Branch': str(branch[0]._id),
                                  'ES-Password': branch[0].password
                              })

        client = AsyncHTTPClient(self.io_loop)
        client.fetch(request, self.handle_request_token)
        token = self.wait()

        password = bcrypt.encrypt('1234')
        users = []

        for index in range(0, DATABASE_LIMIT * 2):
            random = uuid.uuid4()
            user = User(first_name='APIUsersPaginationTest' + str(random),
                        last_name='last_name' + str(random),
                        email='email' + str(random) + '@localhost.com',
                        password=password,
                        status='Active',
                        credits=300)

            users.append(user)

        User.objects.bulk_insert(users, callback=self.stop)
        self.wait()

        request = HTTPRequest('{}/api/users'.format(self.base_url),
                              headers={'ES-Token': token})

        client = AsyncHTTPClient(self.io_loop)
        client.fetch(request, self.handle_fetch)
        self.wait()

        request = HTTPRequest('{}/api/users?page=1'.format(self.base_url),
                              headers={'ES-Token': token})

        client = AsyncHTTPClient(self.io_loop)
        client.fetch(request, self.handle_fetch)
        self.wait()

        User.objects \
            .filter({'first_name': {'$regex': '^APIUsersPaginationTest'}}) \
            .delete(callback=self.stop)
        self.wait()
Esempio n. 26
0
    def test_crud_single(self):
        self.thisHostMustNot(platform='windows')
        client = AsyncHTTPClient(self.io_loop)

        # Can we create a tufo?
        data = json.dumps({'foo': 'val1', 'key2': 'val2'})
        tufo = {'foo': 'val1', 'foo:foo': 'val1', 'foo:key2': 'val2', 'tufo:form': 'foo'}
        resp = yield client.fetch(self.host + '/v1/foo', method='POST', body=data, headers={'Content-Type': 'application/json'})
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        #self.assertEqual(resp['ret'][1], tufo)
        self.assertDictMust(resp['ret'][1], tufo)
        iden = resp['ret'][0]

        # Does it persist?
        resp = yield client.fetch(self.host + '/v1/foo/' + iden)
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        self.assertEqual(resp['ret'], [iden, tufo])

        # Can it be updated?
        data = json.dumps({'key2': 'val22', 'key3': 'val3'})
        tufo = {'foo': 'val1', 'foo:foo': 'val1', 'foo:key2': 'val22', 'foo:key3': 'val3', 'tufo:form': 'foo'}
        resp = yield client.fetch(self.host + '/v1/foo/' + iden, method='PATCH', body=data, headers={'Content-Type': 'application/json'})
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        self.assertEqual(resp['ret'][1], tufo)

        # Can it be deleted?
        resp = yield client.fetch(self.host + '/v1/foo/' + iden, method='DELETE')
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')

        resp = yield client.fetch(self.host + '/v1/foo/' + iden)
        resp = json.loads(resp.body.decode('utf-8'))
        self.assertEqual(resp['status'], 'ok')
        assert resp['ret'] is None
Esempio n. 27
0
    def test_ststderrderrshell_get_user(self):
        post_data = {
            # 'user_info': json_encode(user_info),
            'host': host,
            'module': 'shell',
            'args': 'hostname1',
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
        result = json_decode(response.body)
        print(result)
    def test_fetch(self):
        dir = os.path.dirname(os.path.realpath(__file__))

        with open('{}/config.yaml'.format(dir), 'r') as stream:
            config = yaml.load(stream)
            self.base_url = config['base_url']

        connect_db(self.io_loop)

        Branch.objects.limit(1).find_all(callback=self.stop)
        branch = self.wait()
        Instructor.objects.limit(2).find_all(callback=self.stop)
        instructors = self.wait()

        self.schedule = InstructorSchedule()
        self.schedule.branch = branch[0]._id
        self.schedule.seats = 37
        self.schedule.start = parser.parse('1:0', default=self.DEFAULT_TIME)
        self.schedule.end = parser.parse('2:0', default=self.DEFAULT_TIME)
        self.schedule.date = parser.parse(date.today().strftime('%Y-%m-%d'))
        self.schedule.type = 'any'
        self.schedule.instructor = instructors[0]._id
        self.schedule.sub_instructor = instructors[1]._id

        self.schedule.save(callback=self.stop)
        self.wait()

        client = AsyncHTTPClient(self.io_loop)
        client.fetch(
            '{}/admin/schedule?date={}'.format(
                self.base_url,
                date.today().strftime('%Y-%m-%d')), self.handle_fetch)
        self.wait()

        self.schedule.delete(callback=self.stop)
        self.wait()
 def test_rewards_data(self):
     """Call the '/rewards' endpoint and test that the output.
     Verifies that the output can be parsed as JSON and the data matches
     the supplied test data.
     """
     client = AsyncHTTPClient(self.io_loop)
     response = yield client.fetch("http://localhost:7050/rewards")
     self.assertEqual(response.code, 200)
     # Decode bytes into utf-8 string and parse the JSON
     data = json.loads(response.body.decode('utf-8'))
     # Sort the JSON output so we know the first tier is tier A,
     # at least based on the supplied test data.
     rewards = sorted(data, key=itemgetter("points"))
     self.assertEqual("A", rewards[0]["tier"])
     self.assertEqual(100, rewards[0]["points"])
     self.assertEqual("5% off purchase", rewards[0]["rewardName"])
Esempio n. 30
0
    def test_masquerade(self):
        post_data = {
            'user_info': json_encode(user_info),
            'host': host,
            'permanent': 'true',
            'state': 'enabled',
            'masquerade': 'yes',
            'zone': 'public',
            'module': 'firewalld'
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 31
0
    def test_add_user_groups(self):
        post_data = {
            'user_info': json_encode(user_info),
            'host': host,
            'module': 'user',
            'state': 'present',
            'name': 'test3',
            'password': password,
            'groups': 'test2,root'
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 32
0
    def test_service(self):
        post_data = {
            'user_info': json_encode(user_info),
            'host': host,
            'permanent': 'false',
            'state': 'enabled',
            'service': 'http',
            'immediate': 'false',
            'module': 'firewalld'
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 33
0
    def test_update_passwd(self):
        new_passwd = sha512_crypt.using(rounds=5000).hash('milan')
        print(new_passwd)
        post_data = {
            'user_info': json_encode(user_info),
            'host': host,
            'module': 'user',
            'name': 'test2',
            'state': 'update',
            'password': new_passwd,
            'update_password': '******'
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 34
0
    def test_del(self):
        post_data = {
            'user_info': json_encode(user_info),
            'module': 'yum_repo',
            'host': host,
            'name': 'wanda',
            'state': 'absent',
            'description': 'local',
            'enabled': '1',
            'gpgcheck': '0',
            'baseurl': 'http://yum.wanda.cn'
        }

        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='POST',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 35
0
    def test_add(self):

        post_data = {
            "server_id": 17,
            "server_name": "slave23",
            "manager_ip": "172.16.250.23",
            "ilo4_user_name": "admin",
            "ilo4_user_passwd": "cGFzc3dvcmQ=",
            "server_ip": "172.16.251.106",
            "server_group": "test",
            "server_idc": "成都",
            "pt_id": 2
        }
        client = AsyncHTTPClient(self.io_loop)
        response = yield client.fetch(TEST_URL,
                                      method='PUT',
                                      body=json_encode(post_data))
        print(response.body)
Esempio n. 36
0
class TestHandlerBase(AsyncTestCase):
    def setUp(self):
        super(TestHandlerBase, self).setUp()
        self.client = AsyncHTTPClient(self.io_loop)


    def tearDown(self):
        pass

    def testgetItems(self):
        res = self.client.fetch('ok')
        self.wait()
        assert res.code == 412


    def get_app(self):
        import alfred.webserver
        return alfred.webserver.WebServer().start()
Esempio n. 37
0
    def test_login(self):

        client = AsyncHTTPClient(self.io_loop)


        message0 = {"type": "login", "payload": "django"}

        url = self.get_url('/mr.login?message=' + urllib.parse.quote(json.dumps(message0)))

        response = yield client.fetch(url, method='GET')

        self.assertEqual(response.code, 200)

        bodystr = None
        try:
            bodystr = response.body.decode("utf-8")
        except ValueError:
            self.fail("Mr. Login gave an invalid response to a login; it was not valid utf-8; response: %s" % repr(response.body))


        login_response = None
        try:
            login_response = json.loads(bodystr)
        except ValueError:
            self.fail("Mr. Login gave an invalid response to a login; it was not valid json; response: %s" % repr(response.body))

        
        self.assertTrue( isinstance(login_response, dict), msg=login_response )


        self.assertTrue( 'success' in login_response, msg=login_response )
        self.assertTrue( isinstance(login_response['success'], bool), msg=login_response )
        self.assertTrue( login_response['success'], msg=login_response )



        self.assertTrue( 'msg' in login_response, msg=login_response )
        self.assertTrue( isinstance(login_response['msg'], str), msg=login_response )


        cache = self.myapp.global_message_buffer.cache
        self.assertTrue( len(cache) > 0, msg=cache )
        self.assertTrue( cache[-1]['type'] == message0['type'] )
        self.assertTrue( cache[-1]['payload'] == message0['payload'] )
Esempio n. 38
0
    def test_login(self):

        client = AsyncHTTPClient(self.io_loop)

        message0 = {"type": "login", "payload": "django"}

        url = self.get_url('/mr.login?message=' +
                           urllib.parse.quote(json.dumps(message0)))

        response = yield client.fetch(url, method='GET')

        self.assertEqual(response.code, 200)

        bodystr = None
        try:
            bodystr = response.body.decode("utf-8")
        except ValueError:
            self.fail(
                "Mr. Login gave an invalid response to a login; it was not valid utf-8; response: %s"
                % repr(response.body))

        login_response = None
        try:
            login_response = json.loads(bodystr)
        except ValueError:
            self.fail(
                "Mr. Login gave an invalid response to a login; it was not valid json; response: %s"
                % repr(response.body))

        self.assertTrue(isinstance(login_response, dict), msg=login_response)

        self.assertTrue('success' in login_response, msg=login_response)
        self.assertTrue(isinstance(login_response['success'], bool),
                        msg=login_response)
        self.assertTrue(login_response['success'], msg=login_response)

        self.assertTrue('msg' in login_response, msg=login_response)
        self.assertTrue(isinstance(login_response['msg'], str),
                        msg=login_response)

        cache = self.myapp.global_message_buffer.cache
        self.assertTrue(len(cache) > 0, msg=cache)
        self.assertTrue(cache[-1]['type'] == message0['type'])
        self.assertTrue(cache[-1]['payload'] == message0['payload'])
Esempio n. 39
0
 def test_http_fetch(self):
     print("testMainHandler")
     client = AsyncHTTPClient(self.io_loop)
     response = yield client.fetch("http://localhost:8080")
     # Test contents of response
     self.assertEqual("hello world", response.body)
Esempio n. 40
0
    def test_broadcast(self):



        message0 = {"type": "login", "payload": "django"}

        @tornado.gen.coroutine
        def do_login():

            client = AsyncHTTPClient(self.io_loop)
            #examlpe url: /mr.login?message=<message in JSON>&other_data_for_the_query_string=value
            url = self.get_url('/mr.login?message=' + urllib.parse.quote(json.dumps(message0)))

            response = yield client.fetch(url, method='GET')

            self.assertEqual(response.code, 200)


        yield do_login()



        client = AsyncHTTPClient(self.io_loop)

        url = self.get_url('/mr.broadcaster?cursor=100002325435')
        response = yield client.fetch(url, method='GET')
        self.assertEqual(response.code, 200)

        bodystr = None
        try:
            bodystr = response.body.decode("utf-8")
        except ValueError:
            self.fail("Mr. Broadcaster gave an invalid response to a broadcast request; it was not valid utf-8; response: %s" % repr(response.body))


        broadcast = None
        try:
            broadcast = json.loads(bodystr)
        except ValueError:
            self.fail("Mr. Broadcaster gave an invalid response to a broadcast request; it was not valid json; response: %s" % repr(response.body))


        self.assertTrue( isinstance(broadcast, dict), msg=broadcast )

        self.assertTrue( 'messages' in broadcast, msg=broadcast )
        self.assertTrue( isinstance(broadcast['messages'], list), msg=broadcast )


        found_login_message = False

        for message in broadcast['messages']:

            self.assertTrue( isinstance(message, dict), msg=message )



            self.assertTrue( 'id' in message, msg=message )
            self.assertTrue( isinstance(message['id'], (int,str)), msg=message )



            self.assertTrue( 'type' in message, msg=message )
            self.assertTrue( isinstance(message['type'], str), msg=message )
            self.assertTrue( message['type'] in ['login'], msg=message )



            self.assertTrue( 'payload' in message, msg=message )

            if (message['type'] == 'login'):
                self.assertTrue( isinstance(message['payload'], str), msg=message )



            if message['type'] == 'login' and message['payload'] == 'django':
                found_login_message = True



        self.assertTrue(found_login_message
                            , msg='Did not find the expected login message that we gave Mr. login; message0: %s, broadcast: %s'
                                     % (message0, broadcast))
Esempio n. 41
0
 def test_http_fetch(self):
     client = AsyncHTTPClient(self.io_loop)
     client.fetch("http://www.tornadoweb.org/", self.handle_fetch)
     self.wait()
Esempio n. 42
0
 def test_http_fetch(self):
     client = AsyncHTTPClient(self.io_loop)
     client.fetch("http://www.tornadoweb.org/", self.stop)
     response = self.wait()
     # Test contents of response
     self.assertIn("FriendFeed", response.body)
Esempio n. 43
0
	def test_index_fetch(self):
		client = AsyncHTTPClient(self.io_loop)
		
		resp = yield client.fetch(INDEX_URL)
		self.assertIn("hello", resp.body)
 def test_http_fetch(self):
     client = AsyncHTTPClient(self.io_loop)
     client.fetch("http://www.baidu.com/", self.handle_fetch)
     self.wait()
 def test_http_fetch(self):
     client = AsyncHTTPClient(self.io_loop)
     client.fetch("http://www.baidu.com/", self.stop)
     response = self.wait()
     print(response)
 def test_http_fetch(self):
     client = AsyncHTTPClient(self.io_loop)
     response = yield client.fetch("http://www.baidu.com")
     # Test contents of response
     print(response)