def test_prpcrypto():
    key = "ReUrr0NKeHkppBQq"

    assert len(key) == 16

    crypto = PrpCrypto(key)
    text = generate_token(32)
    app_id = generate_token(32)
    assert crypto.decrypt(crypto.encrypt(text, app_id),
                          app_id) == to_binary(text)

def test_config_attribute():
    robot = WeRoBot(enable_session=False)
    assert not robot.token
    token = generate_token()
    robot.config["TOKEN"] = token
    assert robot.token == token

    token = generate_token()
    robot.token = token
    assert robot.config["TOKEN"] == token

def test_config_attribute():
    robot = WeRoBot(SESSION_STORAGE=False)
    assert not robot.token
    token = generate_token()
    robot.config["TOKEN"] = token
    assert robot.token == token

    token = generate_token()
    robot.token = token
    assert robot.config["TOKEN"] == token

    def create_js_edit_address_param(self, accesstoken, **params):
        """
        alpha
        暂时不建议使用
        这个接口使用起来十分不友好
        而且会引起巨大的误解

        url 需要带上 code 和 state (url?code=xxx&state=1)
        code 和state 是 oauth 时候回来的

        token 要传用户的 token

        这尼玛 你能相信这些支付接口都是腾讯出的？
        """
        params.update({
            'appId': self.appid,
            'nonceStr': generate_token(8),
            'timeStamp': int(time.time())
        })

        _params = [(k.lower(), str(v)) for k, v in params.items()]
        _params += [('accesstoken', accesstoken)]
        _params.sort()

        string1 = '&'.join(["%s=%s" % (p[0], p[1]) for p in _params])
        sign = sha1(string1).hexdigest()

        params = dict([(k, str(v)) for k, v in params.items()])

        params['addrSign'] = sign
        params['signType'] = 'sha1'
        params['scope'] = params.get('scope', 'jsapi_address')

        return params

    def get_public_key(self, **kwargs):
        """
        获取企业支付PKCS 银行账户名，账户加密公钥
        """
        xml_data = """
            <xml>
            <mch_id>{mch_id}</mch_id>
            <nonce_str>{nonce_str}</nonce_str>
            <sign_type>{sign_type}</sign_type>
            <sign>{sign}</sign>
            </xml>
        """
        kwargs.update({
                "nonce_str": generate_token(),
                "mch_id": self.partner_id,
                "sign_type": "MD5"
            })

        sign, _ = get_sign(kwargs, sign_type="MD5", pay_sign_key=self.pay_sign_key)
        kwargs['sign'] = sign

        xml_data = xml_data.format(**kwargs)


        json = self.post(PUBLIC_KEY_URI, data=xml_data, cert=(APICLIENT_CERT, APICLIENT_KEY), verify=True)

        return_code = json.get('return_code')
        if return_code == 'SUCCESS':
            public_key = json.get("pub_key")
            # wirte public key to file
            with open(PUBLIC_PEM, 'w') as pem:
                pem.write(public_key)
        return json

    def get_transfer_info(self, **kwargs):
        """
        查询企业付款到零钱
        """
        xml_data = """
            <xml>
                 <sign><![CDATA[{sign}]]></sign>
                 <partner_trade_no><![CDATA[{partner_trade_no}]]></partner_trade_no>
                 <mch_id ><![CDATA[{mch_id}]]></mch_id >
                 <appid><![CDATA[{appid}]]></appid>
                 <nonce_str><![CDATA[{nonce_str}]]></nonce_str>
            </xml>
        """

        kwargs.update({
                "mch_id": self.partner_id,
                "appid": self.appid,
                "nonce_str": generate_token()
            })

        sign, _ = get_sign(kwargs, pay_sign_key=self.pay_sign_key)
        kwargs['sign'] = sign


        json = self.post(QUERY_TRANSFER_INFO_URI, data=xml_data, cert=(APICLIENT_CERT, APICLIENT_KEY), verify=True)
        return json

    def query_bank(self, **kwargs):
        """
        查询企业付款银行卡
        """
        xml_data = """
            <xml>
            <mch_id>{mch_id}</mch_id>
            <nonce_str>{nonce_str}</nonce_str>
            <partner_trade_no>{partner_trade_no}</partner_trade_no>
            <sign>{sign}</sign>
            </xml>
        """
        kwargs.update({
                "mch_id": self.partner_id,
                "nonce_str": generate_token(),
            })

        sign, _ = get_sign(kwargs, pay_sign_key=self.pay_sign_key)
        kwargs['sign'] = sign

        xml_data = xml_data.format(**kwargs)


        json = self.post(QUERY_BANK_URI, data=xml_data, cert=(APICLIENT_CERT, APICLIENT_KEY), verify=True)
        return json

    def orderquery(self, **package):
        """
        订单查询
        返回订单支付状态
        """
        xml_data = """
            <xml>
            <appid>{appid}</appid>
            <mch_id>{mch_id}</mch_id>
            <nonce_str>{nonce_str}</nonce_str>
            <out_trade_no>{out_trade_no}</out_trade_no>
            <sign><![CDATA[{sign}]]></sign>
            </xml>
        """
        package.update({
            "appid": self.appid,
            "mch_id": self.partner_id,
            "nonce_str": generate_token(),
        })
        # 根据参与签名参数得到签名
        sign, _ = get_sign(package, pay_sign_key=self.pay_sign_key)
        package['sign'] = sign
        # 转换xml数据
        xml_data = xml_data.format(**package)

        json = self.post(ORDER_QUERY, data=xml_data)
        if json["return_code"] == "SUCCESS" and json['result_code'] == "SUCCESS":
            return json['trade_state'], json
        return 0, {}

    def get_line_scan_callback_xml(self, **kw):
        """
        组织线下支付回调返回prepay_id xml数据
        """
        xml_data = """<xml>
            <return_code>{return_code}</return_code>
            <result_code>{result_code}</result_code>
            <appid>{appid}</appid>
            <mch_id>{mch_id}</mch_id>
            <prepay_id><![CDATA[{prepay_id}]]></prepay_id>
            <nonce_str><![CDATA[{nonce_str}]]></nonce_str>
            <sign><![CDATA[{sign}]]></sign>
            </xml>
        """
        kw.update({
            "appid": self.appid,
            "mch_id": self.partner_id,
            "nonce_str": generate_token(),
        })
        # 根据参与签名参数得到签名
        sign, _ = get_sign(kw, pay_sign_key=self.pay_sign_key)
        kw['sign'] = sign
        # 转换xml数据
        xml_data = xml_data.format(**kw)
        

        return xml_data

def test_django():
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_test.settings")
    sys.path.append(
        os.path.join(
            os.path.abspath(os.path.dirname(__file__)), 'django_test_env'
        )
    )

    from django.test.utils import setup_test_environment
    setup_test_environment()
    from django.test.client import Client
    from werobot.parser import parse_xml, process_message
    import django

    django.setup()
    client = Client()

    token = 'TestDjango'
    timestamp = str(time.time())
    nonce = str(random.randint(0, 10000))
    signature = get_signature(token, timestamp, nonce)
    echostr = generate_token()

    response = client.get(
        '/robot/', {
            'signature': signature,
            'timestamp': timestamp,
            'nonce': nonce,
            'echostr': echostr
        }
    )
    assert response.status_code == 200
    assert response.content.decode('utf-8') == echostr

    xml = """
    <xml>
        <ToUserName><![CDATA[toUser]]></ToUserName>
        <FromUserName><![CDATA[fromUser]]></FromUserName>
        <CreateTime>1348831860</CreateTime>
        <MsgType><![CDATA[text]]></MsgType>
        <Content><![CDATA[this is a test]]></Content>
        <MsgId>1234567890123456</MsgId>
    </xml>"""
    params = "?timestamp=%s&nonce=%s&signature=%s" % \
             (timestamp, nonce, signature)
    url = '/robot/'
    response = client.post(url, data=xml, content_type="text/xml")

    assert response.status_code == 403
    assert response.content.decode('utf-8') == u'喵'

    url += params
    response = client.post(url, data=xml, content_type="text/xml")

    assert response.status_code == 200
    response = process_message(parse_xml(response.content))
    assert response.content == 'hello'

    response = client.options(url)
    assert response.status_code == 405

    def pay_to_bank(self, **kwargs):
        """
        企业付款到银行卡
        kwargs['amount'] = 1
        kwargs['bank_code'] = 1002
        kwargs['bank_note'] = 'test'
        kwargs['desc'] = 'test'
        kwargs['bank_no'] = '6212261001014506692'
        kwargs['true_name'] = '向进'
        kwargs['partner_trade_no'] = str(self._now_time)
        """
        xml_data = """
            <xml>
            <amount>{amount}</amount>
            <bank_code>{bank_code}</bank_code>
            <bank_note>{bank_note}</bank_note>
            <desc>{desc}</desc>
            <enc_bank_no>{enc_bank_no}</enc_bank_no>
            <enc_true_name>{enc_true_name}</enc_true_name>
            <mch_id>{mch_id}</mch_id>
            <nonce_str>{nonce_str}</nonce_str>
            <partner_trade_no>{partner_trade_no}</partner_trade_no>
            <sign>{sign}</sign>
            </xml>
        """
        kwargs.update({
                "mch_id": self.partner_id,
                "nonce_str": generate_token(),
            })
        
        bank_no = kwargs.pop("bank_no", None)
        true_name = kwargs.pop("true_name", None)
        if not (bank_no and true_name):
            raise PayException("bank_no and true_name is required")

        # enc_bank_no, enc_true_name 加密
        enc_bank_no = self.signature(bank_no)
        enc_true_name = self.signature(true_name)

        kwargs['enc_bank_no'] = enc_bank_no
        kwargs['enc_true_name'] = enc_true_name

        sign, _ = get_sign(kwargs, pay_sign_key=self.pay_sign_key)
        kwargs['sign'] = sign
        logger.info("请求提现到银行卡的参数:{}".format(kwargs))
        xml_data = xml_data.format(**kwargs).encode("utf-8")


        json = self.post(PAY_BANK_URI, data=xml_data, cert=(APICLIENT_CERT, APICLIENT_KEY), verify=True)
        result_code = json.get("result_code")
        # SYSTEMERROR, INVALID_REQUEST 微信系统错误，需要使用原请求参数进行重试
        # if result_code in ("SYSTEMERROR", "INVALID_REQUEST"):
        #     del kwargs['sign']
        #     self.pay_to_bank(**kwargs)

        return json

def test_message_crypt():
    encoding_aes_key = generate_token(32) + generate_token(11)
    token = generate_token()
    timestamp = to_text(int(time.time()))
    nonce = generate_token(5)
    app_id = generate_token(18)
    crypt = MessageCrypt(
        token=token, encoding_aes_key=encoding_aes_key, app_id=app_id
    )

    message = crypt.encrypt_message('hello', timestamp, nonce)
    assert message is not None
    message = parse_xml(message)
    assert message is not None
    message = crypt.decrypt_message(
        message['TimeStamp'], message['Nonce'], message['MsgSignature'],
        message['Encrypt']
    )
    assert message == to_binary('hello')

def test_tornado(wsgi_tester, hello_robot):
    from tornado.wsgi import WSGIAdapter
    import tornado.web
    from werobot.contrib.tornado import make_handler

    token = generate_token()
    endpoint = r'/werobot_tornado'
    hello_robot.token = token

    tornado_app = tornado.web.Application([
        (endpoint, make_handler(hello_robot)),
    ], debug=True)
    wsgi_tester(WSGIAdapter(tornado_app), token=token, endpoint=endpoint)

def test_bottle(wsgi_tester, hello_robot):
    from werobot.contrib.bottle import make_view
    from bottle import Bottle

    token = generate_token()
    endpoint = '/werobot_bottle'

    hello_robot.token = token

    bottle_app = Bottle()
    bottle_app.route(endpoint, ['GET', 'POST'], make_view(hello_robot))

    wsgi_tester(bottle_app, token=token, endpoint=endpoint)

    def promotion_transfers(self, **kwargs):
        """
        提现到零钱
        """
        xml_data = """
            <xml>
            <mch_appid>{mch_appid}</mch_appid>
            <mchid>{mchid}</mchid>
            <nonce_str>{nonce_str}</nonce_str>
            <partner_trade_no>{partner_trade_no}</partner_trade_no>
            <openid>{openid}</openid>
            <check_name>{check_name}</check_name>
            <re_user_name>{re_user_name}</re_user_name>
            <amount>{amount}</amount>
            <desc>{desc}</desc>
            <spbill_create_ip>{spbill_create_ip}</spbill_create_ip>
            <sign>{sign}</sign>
            </xml>
        """
        kwargs.update({
                "mch_appid": self.appid,
                "mchid": self.partner_id,
                "nonce_str": generate_token(),
            })

        # kwargs['partner_trade_no'] = str(self._now_time)
        # kwargs['openid'] = 'oANoEwGS99wH34zfu-dYaCzoV0cM'
        # kwargs['check_name'] = 'NO_CHECK'
        # kwargs['re_user_name'] = '向进'
        # kwargs['amount'] = 100
        # kwargs['desc'] = 'desc'
        # kwargs['spbill_create_ip'] = '139.227.252.215'

        sign, _ = get_sign(kwargs, pay_sign_key=self.pay_sign_key)
        kwargs['sign'] = sign

        logger.info("Wechat Pay Arguments: {}".format(kwargs))

        xml_data = xml_data.format(**kwargs).encode("utf-8")

        json = self.post(PROMOTION_TRANSFERS_URI, data=xml_data, cert=(APICLIENT_CERT, APICLIENT_KEY), verify=True)

        result_code = json.get("result_code")
        if result_code == "FAIL":
            err_code = json.get("err_code")
            if err_code in ("SYSTEMERROR", "INVALID_REQUEST"):
                # 使用原订单号请求
                del kwargs['sign']
                self.promotion_transfers(**kwargs)

        return json

 def get_line_url(self, **kw):
     """
     获取线下二维码url
     :return:
     """
     kw.update({
         "appid": self.appid,
         "mch_id": self.partner_id,
         "nonce_str": generate_token(),
         "time_stamp": self._now_time
     })
     # 根据参与签名参数得到签名
     sign, _ = get_sign(kw, pay_sign_key=self.pay_sign_key)
     kw['sign'] = sign
     url = self.line_url.format(**kw)
     return url

def test_signature_checker():
    token = generate_token()

    robot = WeRoBot(token, SESSION_STORAGE=False)

    timestamp = str(int(time.time()))
    nonce = '12345678'

    sign = [token, timestamp, nonce]
    sign.sort()
    sign = ''.join(sign)
    if six.PY3:
        sign = sign.encode()
    sign = hashlib.sha1(sign).hexdigest()

    assert robot.check_signature(timestamp, nonce, sign)

 def jsconfig(self, **kwargs):
     """
     得到jsconfig 配置信息
     """
     json = {
         "noncestr": generate_token(),
         "jsapi_ticket": self.jsticket,
         "timestamp": self._now_time,
         "url": kwargs.pop("url", JSPARAMS_URI)
     }
     # 根据参与签名参数得到签名
     sign_type = 'SHA1'
     sign, _ = get_sign(json, sign_type=sign_type, is_upper=False)
     json['sign'] = sign
     json["appid"] = self.appid
     return json, sign, sign_type

    def test_tornado(self):
        token = self.token
        timestamp = str(time.time())
        nonce = str(random.randint(0, 10000))
        signature = get_signature(token, timestamp, nonce)
        echostr = generate_token()

        params = "?timestamp=%s&nonce=%s&signature=%s&echostr=%s" % (
            timestamp, nonce, signature, echostr
        )

        response = self.fetch(path=self.endpoint + params)
        assert response.code == 200
        assert response.body.decode('utf-8') == echostr

        response = self.fetch(path=self.endpoint, )
        assert response.code == 403
        assert response.body.decode('utf-8') == u'喵'

        xml = """
        <xml>
            <ToUserName><![CDATA[toUser]]></ToUserName>
            <FromUserName><![CDATA[fromUser]]></FromUserName>
            <CreateTime>1348831860</CreateTime>
            <MsgType><![CDATA[text]]></MsgType>
            <Content><![CDATA[this is a test]]></Content>
            <MsgId>1234567890123456</MsgId>
        </xml>"""

        response = self.fetch(
            path=self.endpoint + params,
            method='POST',
            body=xml,
            headers={'Content-Type': 'text/xml'}
        )
        self.assertEqual(response.code, 200)
        self.assertEqual(
            process_message(parse_xml(response.body)).content, 'hello'
        )

        response = self.fetch(
            path=self.endpoint,
            method='POST',
            body=xml,
            headers={'Content-Type': 'text/xml'}
        )
        self.assertEqual(response.code, 403)

    def tester(app, token, endpoint):
        test_app = webtest.TestApp(app)

        response = test_app.get(endpoint, expect_errors=True)
        assert response.status_code == 403

        timestamp = str(time.time())
        nonce = str(random.randint(0, 10000))
        signature = get_signature(token, timestamp, nonce)
        echostr = generate_token()

        params = "?timestamp=%s&nonce=%s&signature=%s&echostr=%s" % (
            timestamp, nonce, signature, echostr
        )
        response = test_app.get(endpoint + params)

        assert response.status_code == 200
        assert response.body.decode('utf-8') == echostr

        response = test_app.get(endpoint, expect_errors=True)

        assert response.status_code == 403
        assert response.body.decode('utf-8') == u'喵'

        xml = """
                <xml>
                    <ToUserName><![CDATA[toUser]]></ToUserName>
                    <FromUserName><![CDATA[fromUser]]></FromUserName>
                    <CreateTime>1348831860</CreateTime>
                    <MsgType><![CDATA[text]]></MsgType>
                    <Content><![CDATA[this is a test]]></Content>
                    <MsgId>1234567890123456</MsgId>
                </xml>
                """
        with pytest.raises(AppError):
            # WebTest will raise an AppError
            # if the status_code is not >= 200 and < 400.
            test_app.post(endpoint, xml, content_type="text/xml")

        response = test_app.post(
            endpoint + params, xml, content_type="text/xml"
        )

        assert response.status_code == 200
        response = process_message(parse_xml(response.body))
        assert response.content == 'hello'