def test_development_env(self):
        """
        Test traceback thrown in development env
        """
        setup_server()
        # test 404
        resp = json.loads(request('/tasks/blah').read())
        self.assertEquals('404 Not Found', resp.get('code'))

        # test 405 wrong method
        resp = json.loads(request('/', None, 'DELETE').read())
        msg = u'WOKAPI0002E: Delete is not allowed for wokroot'
        self.assertEquals('405 Method Not Allowed', resp.get('code'))
        self.assertEquals(msg, resp.get('reason'))

        # test 400 parse error
        resp = json.loads(request('/tasks', '{', 'POST').read())
        msg = u'WOKAPI0006E: Unable to parse JSON request'
        self.assertEquals('400 Bad Request', resp.get('code'))
        self.assertEquals(msg, resp.get('reason'))
        self.assertIn('call_stack', resp)

        # test 405 method not allowed
        req = json.dumps({})
        resp = json.loads(request('/tasks', req, 'POST').read())
        m = u"WOKAPI0005E: Create is not allowed for tasks"
        self.assertEquals('405 Method Not Allowed', resp.get('code'))
        self.assertEquals(m, resp.get('reason'))
        self.assertIn('call_stack', resp)

    def test_development_env(self):
        """
        Test traceback thrown in development env
        """
        setup_server()
        # test 404
        resp = json.loads(request(host, ssl_port, '/vms/blah').read())
        self.assertEquals('404 Not Found', resp.get('code'))

        # test 405 wrong method
        resp = json.loads(request(host, ssl_port, '/', None, 'DELETE').read())
        msg = u'KCHAPI0002E: Delete is not allowed for kimchiroot'
        self.assertEquals('405 Method Not Allowed', resp.get('code'))
        self.assertEquals(msg, resp.get('reason'))

        # test 400 parse error
        resp = json.loads(request(host, ssl_port, '/vms', '{', 'POST').read())
        msg = u'KCHAPI0006E: Unable to parse JSON request'
        self.assertEquals('400 Bad Request', resp.get('code'))
        self.assertEquals(msg, resp.get('reason'))
        self.assertIn('call_stack', resp)

        # test 400 missing required parameter
        req = json.dumps({})
        resp = json.loads(request(host, ssl_port, '/vms', req, 'POST').read())
        msg = u"KCHVM0016E: Specify a template to create a virtual machine from"
        self.assertEquals('400 Bad Request', resp.get('code'))
        self.assertEquals(msg, resp.get('reason'))
        self.assertIn('call_stack', resp)

    def test_screenshot_refresh(self):
        # Create a VM
        req = json.dumps({'name': 'test', 'cdrom': '/nonexistent.iso'})
        request(host, ssl_port, '/templates', req, 'POST')
        req = json.dumps({'name': 'test-vm', 'template': '/templates/test'})
        request(host, ssl_port, '/vms', req, 'POST')

        # Test screenshot refresh for running vm
        request(host, ssl_port, '/vms/test-vm/start', '{}', 'POST')
        resp = request(host, ssl_port, '/vms/test-vm/screenshot')
        self.assertEquals(200, resp.status)
        self.assertEquals('image/png', resp.getheader('content-type'))
        resp1 = request(host, ssl_port, '/vms/test-vm')
        rspBody = resp1.read()
        testvm_Data = json.loads(rspBody)
        screenshotURL = testvm_Data['screenshot']
        time.sleep(5)
        resp2 = request(host, ssl_port, screenshotURL)
        self.assertEquals(200, resp2.status)
        self.assertEquals(resp2.getheader('content-type'),
                          resp.getheader('content-type'))
        self.assertEquals(resp2.getheader('content-length'),
                          resp.getheader('content-length'))
        self.assertEquals(resp2.getheader('last-modified'),
                          resp.getheader('last-modified'))

    def test_vm_list_sorted(self):
        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
        request(host, ssl_port, '/templates', req, 'POST')

        def add_vm(name):
            # Create a VM
            req = json.dumps({'name': name, 'template': '/templates/test'})
            request(host, ssl_port, '/vms', req, 'POST')

        vms = [u'abc', u'bca', u'cab', u'xba']
        for vm in vms:
            add_vm(vm)

        vms.append(u'test')
        self.assertEqual(model.vms_get_list(), sorted(vms))

 def _send_url_request(self, method, url, data=None):
     req = None
     if data:
         req = json.dumps(data)
     resp = request(host, ssl_port, url, req, method)
     rsp_body = resp.read()
     return json.loads(rsp_body), resp.status

def main(stdscr):
    cursor = Cursor(stdscr)
    url = utils.ip + "token/get"
    token = utils.request(url)['token']
    grid = Grid(stdscr, x_limit, y_limit, cursor)
 
    sel_bool = False
    sel_soldiers = []
    
    while True:
        key = stdscr.getch()

        # quit game
        if key == ord('q'):
            exit(stdscr)
    
        # create soldier
        elif key == ord('c'):
            create_soldier(token)
        
        # move cursor
        elif key in directions:
            cursor.move_cursor(key)
        
        # select tiles
        elif key == ord('s') and not sel_bool:
            cursor.select()
            key = 0
            sel_bool = True
            sel_soldiers = []

        # finish selecting
        elif key is ord('s') and sel_bool:
            cursor.deselect()
            x_r = sorted((cursor.select_coords[0], cursor.x))
            y_r = sorted((cursor.select_coords[1], cursor.y))
            debug_file.write(str(x_r) + "\n" + str(y_r) + "\n")
            for x in range(x_r[0], x_r[1]+1):
                for y in range(y_r[0], y_r[1]+1):
                    if (x,y) in grid.grid:
                        debug_file.write("inserting")
                        sel_soldiers.append(grid.grid[(x,y)])
            sel_bool = False
        if key is ord('q'):
            exit(stdscr)
    
        # move soldiers (soldiers must be selected first)
        elif key == ord('m'):
            key = 69
            debug_file.write(str(sel_soldiers))
            if sel_soldiers:
                debug_file.write("moving soldiers\n")   
                move_soldiers(cursor.position(), sel_soldiers)
                sel_bool = False
        elif key == ord('d'):
            raise Exception(grid.request())
        
        grid.debug(str(key))
        grid.update(key, sel_bool)
        grid.display()

    def getContent(self, agent, keyword, page, timescope, region):
        ''' '''
        url = 'http://search.t.qq.com/index.php?k=%s&is_dup=1&pos=174&p=%d' % (keyword, page)
        log.debug('Starting request url: %s' % url)

        result = yield request(agent, url)
        returnValue(result)

 def add_vm(name):
     # Create a VM
     req = json.dumps({'name': name,
                       'template': '/plugins/kimchi/templates/test'})
     task = json.loads(request(host, ssl_port, '/plugins/kimchi/vms',
                       req, 'POST').read())
     wait_task(model.task_lookup, task['id'])

    def test_vm_list_sorted(self):
        req = json.dumps({"name": "test", "cdrom": fake_iso})
        request(host, ssl_port, "/plugins/kimchi/templates", req, "POST")

        def add_vm(name):
            # Create a VM
            req = json.dumps({"name": name, "template": "/plugins/kimchi/templates/test"})
            task = json.loads(request(host, ssl_port, "/plugins/kimchi/vms", req, "POST").read())
            wait_task(model.task_lookup, task["id"])

        vms = [u"abc", u"bca", u"cab", u"xba"]
        for vm in vms:
            add_vm(vm)

        vms.append(u"test")
        self.assertEqual(model.vms_get_list(), sorted(vms))

    def test_vm_list_sorted(self):
        req = json.dumps({'name': 'test', 'cdrom': '/nonexistent.iso'})
        request(host, ssl_port, '/templates', req, 'POST')

        def add_vm(name):

            # Create a VM
            req = json.dumps({'name': name, 'template': '/templates/test'})
            request(host, ssl_port, '/vms', req, 'POST')

        add_vm('bca')
        add_vm('xba')
        add_vm('abc')
        add_vm('cab')

        self.assertEqual(model.vms_get_list(), ['abc', 'bca', 'cab', 'xba'])

def update(who, what, where, host, port=80, url='/uss/sql/update', headers={}):
    """
    :param host: HTTP Request host
    :param port: HTTP Request port
    :param url: HTTP Request url
    :param who: SQL option on which table
    :param what: {"hostname":"node2", "password":"mdsmds"},
    :param where: {"ip":"192.168.1.1"}

    :returns: { id:0 }, id of the node updated.
    """

    d = {}
    d['who'] = who
    d['what'] = what
    d['where'] = where

    try:
        params = json.dumps(d)
        headers["Content-Type"] = "application/json"

        rslt = request(host=host, method='POST', url=url,
                       headers=headers, params=params, port=port)
        return json.loads(rslt)
    except:
        raise

    def test_get_storagepools(self):
        storagepools = json.loads(
            self.request('/plugins/kimchi/storagepools').read()
        )
        self.assertIn('default', [pool['name'] for pool in storagepools])

        with RollbackContext() as rollback:
            # Now add a couple of storage pools
            for i in xrange(3):
                name = u'kīмсhī-storagepool-%i' % i
                req = json.dumps({'name': name, 'type': 'dir',
                                  'path': '/var/lib/libvirt/images/%i' % i})
                resp = self.request('/plugins/kimchi/storagepools', req,
                                    'POST')
                rollback.prependDefer(model.storagepool_delete, name)

                self.assertEquals(201, resp.status)

                # Pool name must be unique
                req = json.dumps({'name': name, 'type': 'dir',
                                  'path': '/var/lib/libvirt/images/%i' % i})
                resp = self.request('/plugins/kimchi/storagepools', req,
                                    'POST')
                self.assertEquals(400, resp.status)

                # Verify pool information
                resp = self.request('/plugins/kimchi/storagepools/%s' %
                                    name.encode("utf-8"))
                p = json.loads(resp.read())
                keys = [u'name', u'state', u'capacity', u'allocated',
                        u'available', u'path', u'source', u'type',
                        u'nr_volumes', u'autostart', u'persistent']
                self.assertEquals(sorted(keys), sorted(p.keys()))
                self.assertEquals(name, p['name'])
                self.assertEquals('inactive', p['state'])
                self.assertEquals(True, p['persistent'])
                self.assertEquals(True, p['autostart'])
                self.assertEquals(0, p['nr_volumes'])

            pools = json.loads(
                self.request('/plugins/kimchi/storagepools').read()
            )
            self.assertEquals(len(storagepools) + 3, len(pools))

            # Create a pool with an existing path
            tmp_path = tempfile.mkdtemp(dir='/var/lib/kimchi')
            rollback.prependDefer(os.rmdir, tmp_path)
            req = json.dumps({'name': 'existing_path', 'type': 'dir',
                              'path': tmp_path})
            resp = self.request('/plugins/kimchi/storagepools', req, 'POST')
            rollback.prependDefer(model.storagepool_delete, 'existing_path')
            self.assertEquals(201, resp.status)

            # Reserved pool return 400
            req = json.dumps({'name': 'kimchi_isos', 'type': 'dir',
                              'path': '/var/lib/libvirt/images/%i' % i})
            resp = request(host, ssl_port, '/plugins/kimchi/storagepools', req,
                           'POST')
            self.assertEquals(400, resp.status)

    def test_vm_list_sorted(self):
        req = json.dumps({'name': 'test', 'cdrom': fake_iso})
        request(host, ssl_port, '/plugins/kimchi/templates', req, 'POST')

        def add_vm(name):
            # Create a VM
            req = json.dumps({'name': name,
                              'template': '/plugins/kimchi/templates/test'})
            task = json.loads(request(host, ssl_port, '/plugins/kimchi/vms',
                              req, 'POST').read())
            wait_task(model.task_lookup, task['id'])

        vms = [u'abc', u'bca', u'cab', u'xba']
        for vm in vms:
            add_vm(vm)

        vms.append(u'test')
        self.assertEqual(model.vms_get_list(), sorted(vms))

 def test_create_debugreport(self):
     req = json.dumps({'name': 'report1'})
     with RollbackContext() as rollback:
         resp = request(host, ssl_port, '/debugreports', req, 'POST')
         self.assertEquals(202, resp.status)
         task = json.loads(resp.read())
         # make sure the debugreport doesn't exist until the
         # the task is finished
         wait_task(self._task_lookup, task['id'])
         rollback.prependDefer(self._report_delete, 'report2')
         resp = request(host, ssl_port, '/debugreports/report1')
         debugreport = json.loads(resp.read())
         self.assertEquals("report1", debugreport['name'])
         self.assertEquals(200, resp.status)
         req = json.dumps({'name': 'report2'})
         resp = request(host, ssl_port, '/debugreports/report1',
                        req, 'PUT')
         self.assertEquals(303, resp.status)

    def test_development_env(self):
        """
        Test traceback thrown in development env
        """
        server_root = '/test'
        setup_server(server_root=server_root)

        # check if server_root in config is the same used to start server
        resp = request(server_root + '/config').read()
        conf = json.loads(resp)
        self.assertEquals(len(conf), 5)

    def test_production_env(self):
        """
        Test reasons sanitized in production env
        """
        server_root = '/test'
        setup_server('production', server_root)

        # check if server_root in config is the same used to start server
        resp = request(server_root + '/config').read()
        conf = json.loads(resp)
        self.assertEquals(len(conf), 5)

 def provisioning_uninstallProduct(self, product, release, fqn, errorType, content):
     """
     uninstall a product-release in a VM
     :param release:
     :param fqn:
     :param NOT_ERROR:
     :param content:
     """
     name = fqn+"_"+product+"_"+release
     world.response = utils.request("DELETE", self.__create__url("uninstallProduct", name), self.__create__headers(content), None, errorType)
     pass

    def test_development_env(self):
        """
        Test traceback thrown in development env
        """
        setup_server()
        # test 404
        resp = json.loads(request(host, ssl_port, '/tasks/blah').read())
        self.assertEquals('404 Not Found', resp.get('code'))

        # test 405 wrong method
        resp = json.loads(request(host, ssl_port, '/', None, 'DELETE').read())
        msg = u'WOKAPI0002E: Delete is not allowed for wokroot'
        self.assertEquals('405 Method Not Allowed', resp.get('code'))
        self.assertEquals(msg, resp.get('reason'))

        # test 400 parse error
        resp = json.loads(request(host, ssl_port, '/tasks', '{',
                                  'POST').read())
        msg = u'WOKAPI0006E: Unable to parse JSON request'
        self.assertEquals('400 Bad Request', resp.get('code'))
        self.assertEquals(msg, resp.get('reason'))
        self.assertIn('call_stack', resp)

        # test 400 missing required parameter
        # TODO: need add this test when some REST API from wok accepts POST
#        req = json.dumps({})
#        resp = json.loads(request(host, ssl_port, '/tasks', req,
#                                   'POST').read())
#        m = u"KCHVM0016E: Specify a template to create a virtual machine from"
#        self.assertEquals('400 Bad Request', resp.get('code'))
#        self.assertEquals(m, resp.get('reason'))
#        self.assertIn('call_stack', resp)

        # test 405 method not allowed
        req = json.dumps({})
        resp = json.loads(request(host, ssl_port, '/tasks', req,
                                  'POST').read())
        m = u"WOKAPI0005E: Create is not allowed for tasks"
        self.assertEquals('405 Method Not Allowed', resp.get('code'))
        self.assertEquals(m, resp.get('reason'))
        self.assertIn('call_stack', resp)

 def _fetch(self, headers={}, d={}, method='POST', url=None):
     params = json.dumps(d)
     headers["Content-Type"] = "application/json"
     host = self.host
     port = self.port
     method = method
     try:
         resp = request(host=host, method=method, url=url,
                              headers=headers, params=params, port=port)
         print d, headers, host, method, url, port, resp
         return json.loads(resp)
     except:
         raise Exception('Bad response from %s' %(host))

 def POST(self):
     self.stage = web.data()
     store.ctx.last_call = time.time()
     try:
         resp = utils.request(utils.request_url, 'GET', {'count': 60, 'mode': 'lite'})
         data = json.loads(resp.read())
         for body in self.filter(data):
             add_task(web.ctx, '/whale/send', json.dumps(body))
     finally:
         if self.stage != utils.stage(): 
             add_task(web.ctx, '/whale/hello', self.stage)
         else:
             time.sleep(4)
             add_task(web.ctx, '/whale/greet', self.stage)