[GNUnet-SVN] [taler-backoffice] 02/02: test GET "/" is 200 OK

[gnunet]

This is an automated email from the git hooks/post-receive script.

marcello pushed a commit to branch master
in repository backoffice.

commit b10a0524ec4248229608aed5891908e85f691864
Author: Marcello Stanisci <address@hidden>
AuthorDate: Fri Jan 5 11:30:27 2018 +0100

    test GET "/" is 200 OK
---
 Makefile.in                              |   4 +
 talerbackoffice/backoffice/backoffice.py | 161 +------------------------------
 talerbackoffice/tests.py                 |  46 ++-------
 3 files changed, 18 insertions(+), 193 deletions(-)

diff --git a/Makefile.in b/Makefile.in
index b0562d1..f71c2a5 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -50,3 +50,7 @@ install: $(templates) install-data
 check:
        @export address@hidden@/talerbackoffice/tests.conf; \
         python3 setup.py test
+
+.PHONY: pyliny
+pylint:
+       @pylint talerbackoffice/
diff --git a/talerbackoffice/backoffice/backoffice.py 
b/talerbackoffice/backoffice/backoffice.py
index 8a48883..f62c78b 100644
--- a/talerbackoffice/backoffice/backoffice.py
+++ b/talerbackoffice/backoffice/backoffice.py
@@ -20,18 +20,15 @@
 Implement URL handlers and payment logic for the blog merchant.
 """
 
-from urllib.parse import urljoin, quote, parse_qsl
+from urllib.parse import urljoin, parse_qsl
 import logging
 import os
 import base64
 import requests
 import flask
 from talerblog.talerconfig import TalerConfig
-from ..helpers import (make_url, \
-    expect_parameter, join_urlparts, \
+from ..helpers import (join_urlparts, \
     get_query_string, backend_error)
-from ..blog.content import (ARTICLES, \
-    get_article_file, get_image_file)
 
 LOGGER = logging.getLogger(__name__)
 
@@ -43,15 +40,12 @@ app.secret_key = 
base64.b64encode(os.urandom(64)).decode('utf-8')
 
 TC = TalerConfig.from_env()
 
-BACKEND_URL = TC["frontends"]["backend"].value_string(required=True)
+BACKEND_URL = os.environ.get("BACKOFFICE_MERCHANT_BACKEND")
+INSTANCES = os.environ.get("BACKOFFICE_INSTANCES") # colon-separated list
 CURRENCY = TC["taler"]["currency"].value_string(required=True)
-INSTANCE = TC["blog"]["instance"].value_string(required=True)
-
-ARTICLE_AMOUNT = dict(value=0, fraction=50000000, currency=CURRENCY)
 
 app.config.from_object(__name__)
 
-
 @app.context_processor
 def utility_processor():
     def url(my_url):
@@ -63,158 +57,13 @@ def utility_processor():
 
 @app.route("/")
 def index():
-    return flask.render_template("templates/index.html",
-                                 merchant_currency=CURRENCY,
-                                 articles=ARTICLES.values())
+    return flask.render_template("templates/backoffice.html")
 
 
 @app.route("/javascript")
 def javascript_licensing():
     return flask.render_template("templates/javascript.html")
 
-# Triggers the refund by serving /refund/test?order_id=XY.
-# Will be triggered by a "refund button".
address@hidden("/refund", methods=["GET", "POST"])
-def refund():
-    if flask.request.method == "POST":
-        payed_articles = flask.session["payed_articles"] = 
flask.session.get("payed_articles", {})
-        article_name = flask.request.form.get("article_name")
-        if not article_name:
-            return flask.jsonify(dict(error="No article_name found in form")), 
400
-        LOGGER.info("Looking for %s to refund" % article_name)
-        order_id = payed_articles.get(article_name)
-        if not order_id:
-            return flask.jsonify(dict(error="Aborting refund: article not 
payed")), 401
-        resp = requests.post(urljoin(BACKEND_URL, "refund"),
-                             json=dict(order_id=order_id,
-                                       refund=ARTICLE_AMOUNT,
-                                       reason="Demo reimbursement",
-                                       instance=INSTANCE))
-        if resp.status_code != 200:
-            return backend_error(resp)
-        payed_articles[article_name] = "__refunded"
-        response = flask.make_response()
-        response.headers["X-Taler-Refund-Url"] = make_url("/refund", 
("order_id", order_id))
-        return response, 402
-
-    else:
-        order_id = expect_parameter("order_id", False)
-        if not order_id:
-            LOGGER.error("Missing parameter 'order_id'")
-            return flask.jsonify(dict(error="Missing parameter 'order_id'")), 
400
-        resp = requests.get(urljoin(BACKEND_URL, "refund"),
-                            params=dict(order_id=order_id, instance=INSTANCE))
-        if resp.status_code != 200:
-            return backend_error(resp)
-        return flask.jsonify(resp.json()), resp.status_code
-
-
address@hidden("/generate-contract", methods=["GET"])
-def generate_contract():
-    article_name = expect_parameter("article_name")
-    pretty_name = article_name.replace("_", " ")
-    order = dict(
-        summary=pretty_name,
-        nonce=flask.request.args.get("nonce"),
-        amount=ARTICLE_AMOUNT,
-        max_fee=dict(value=1, fraction=0, currency=CURRENCY),
-        products=[
-            dict(
-                description="Essay: " + pretty_name,
-                quantity=1,
-                product_id=0,
-                price=ARTICLE_AMOUNT,
-            ),
-        ],
-        fulfillment_url=make_url("/essay/" + quote(article_name)),
-        pay_url=make_url("/pay"),
-        merchant=dict(
-            instance=INSTANCE,
-            address="nowhere",
-            name="Kudos Inc.",
-            jurisdiction="none",
-        ),
-        extra=dict(article_name=article_name),
-    )
-    resp = requests.post(urljoin(BACKEND_URL, "proposal"),
-                         json=dict(order=order))
-    if resp.status_code != 200:
-        return backend_error(resp)
-    proposal_resp = resp.json()
-    return flask.jsonify(**proposal_resp)
-
-
address@hidden("/cc-payment/<name>")
-def cc_payment(name):
-    return flask.render_template("templates/cc-payment.html",
-                                 article_name=name)
-
-
address@hidden("/essay/<name>")
address@hidden("/essay/<name>/data/<data>")
-def article(name, data=None):
-    LOGGER.info("processing %s" % name)
-    payed_articles = flask.session.get("payed_articles", {})
-
-    if payed_articles.get(name, "") == "__refunded":
-        return flask.render_template("templates/article_refunded.html", 
article_name=name)
-
-    if name in payed_articles:
-        articleInfo = ARTICLES[name]
-        if articleInfo is None:
-            flask.abort(500)
-        if data is not None:
-            if data in articleInfo.extra_files:
-                return flask.send_file(get_image_file(data))
-            return "permission denied", 400
-        return flask.render_template("templates/article_frame.html",
-                                     
article_file=get_article_file(articleInfo),
-                                     article_name=name)
-
-    contract_url = make_url("/generate-contract",
-                            ("article_name", name))
-    response = flask.make_response(
-        flask.render_template("templates/fallback.html"), 402)
-    response.headers["X-Taler-Contract-Url"] = contract_url
-    response.headers["X-Taler-Contract-Query"] = "fulfillment_url"
-    # Useless (?) header, as X-Taler-Contract-Url takes always (?) precedence
-    # over X-Offer-Url.  This one might only be useful if the contract 
retrieval
-    # goes wrong.
-    response.headers["X-Taler-Offer-Url"] = make_url("/essay/" + quote(name))
-    return response
-
-
address@hidden("/pay", methods=["POST"])
-def pay():
-    deposit_permission = flask.request.get_json()
-    if deposit_permission is None:
-        return flask.jsonify(error="no json in body"), 400
-    resp = requests.post(urljoin(BACKEND_URL, "pay"),
-                         json=deposit_permission)
-    if resp.status_code != 200:
-        return backend_error(resp)
-    proposal_data = resp.json()["contract_terms"]
-    article_name = proposal_data["extra"]["article_name"]
-    payed_articles = flask.session["payed_articles"] = 
flask.session.get("payed_articles", {})
-
-    try:
-        resp.json()["refund_permissions"].pop()
-        # we had some refunds on the article purchase already!
-        LOGGER.info("Article %s was refunded, before /pay" % article_name)
-        payed_articles[article_name] = "__refunded"
-        return flask.jsonify(resp.json()), 200
-    except IndexError:
-        pass
-
-    if not deposit_permission["order_id"]:
-        LOGGER.error("order_id missing from deposit_permission!")
-        return flask.jsonify(dict(error="internal error: ask for refund!")), 
500
-    if article_name not in payed_articles:
-        LOGGER.info("Article %s goes in state" % article_name)
-        payed_articles[article_name] = deposit_permission["order_id"]
-    return flask.jsonify(resp.json()), 200
-
-
 @app.route("/history")
 def history():
     qs = get_query_string().decode("utf-8")
diff --git a/talerbackoffice/tests.py b/talerbackoffice/tests.py
index 050d852..6fa15cb 100644
--- a/talerbackoffice/tests.py
+++ b/talerbackoffice/tests.py
@@ -2,48 +2,20 @@
 
 import unittest
 from mock import patch, MagicMock
-from talerblog.blog import blog
-from talerblog.talerconfig import TalerConfig
+from talerbackoffice.backoffice import backoffice
+from talerbackoffice.talerconfig import TalerConfig
 
 TC = TalerConfig.from_env()
 CURRENCY = TC["taler"]["currency"].value_string(required=True)
 
-class BlogTestCase(unittest.TestCase):
+class BackofficeTestCase(unittest.TestCase):
     def setUp(self):
-        blog.app.testing = True
-        self.app = blog.app.test_client()
-
-    @patch("requests.post")
-    def test_proposal_creation(self, mocked_post):
-        ret_post = MagicMock()
-        ret_post.status_code = 200
-        ret_post.json.return_value = {}
-        mocked_post.return_value = ret_post
-        self.app.get("/generate-contract?nonce=55&article_name=Check_Me")
-        mocked_post.assert_called_with(
-            "http://backend.test.taler.net/proposal";,
-            json={
-                "order": {
-                    "summary": "Check Me",
-                    "nonce": "55",
-                    "amount": blog.ARTICLE_AMOUNT,
-                    "max_fee": {
-                        "value": 1,
-                        "fraction": 0,
-                        "currency": CURRENCY},
-                    "products": [{
-                        "description": "Essay: Check Me",
-                        "quantity": 1,
-                        "product_id": 0,
-                        "price": blog.ARTICLE_AMOUNT}],
-                    "fulfillment_url": "http://localhost/essay/Check_Me";,
-                    "pay_url": "http://localhost/pay";,
-                    "merchant": {
-                        "instance": 
TC["blog"]["instance"].value_string(required=True),
-                        "address": "nowhere",
-                        "name": "Kudos Inc.",
-                        "jurisdiction": "none"},
-                    "extra": {"article_name": "Check_Me"}}})
+        backoffice.app.testing = True
+        self.app = backoffice.app.test_client()
+    
+    def test_responsive(self):
+        response = self.app.get("/")
+        self.assertEqual(response.status_code, 200)
 
 if __name__ == "__main__":
     unittest.main()

-- 
To stop receiving notification emails like this one, please contact
address@hidden