# -*- coding: utf-8 -*-

"""

 (c) 2015-2018 - Copyright Red Hat Inc

 Authors:

   Pierre-Yves Chibon <pingou@pingoured.fr></pingou@pingoured.fr>

   Karsten Hopp <karsten@redhat.com></karsten@redhat.com>

"""

from __future__ import unicode_literals, absolute_import

import datetime

import json

import unittest

import shutil

import sys

import tempfile

import os

import pygit2

from celery.result import EagerResult

from mock import patch, Mock

sys.path.insert(

    0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..")

)

import pagure.flask_app

import pagure.lib.query

import tests

from pagure.lib.repo import PagureRepo

class PagureFlaskApiProjecttests(tests.Modeltests):

    """ Tests for the flask API of pagure for issue """

    def setUp(self):

        super(PagureFlaskApiProjecttests, self).setUp()

        self.gga_patcher = patch(

            "pagure.lib.tasks.generate_gitolite_acls.delay"

        )

        self.mock_gen_acls = self.gga_patcher.start()

        task_result = EagerResult("abc-1234", True, "SUCCESS")

        self.mock_gen_acls.return_value = task_result

    def tearDown(self):

        self.gga_patcher.stop()

        super(PagureFlaskApiProjecttests, self).tearDown()

    def test_api_git_tags(self):

        """ Test the api_git_tags method of the flask api. """

        tests.create_projects(self.session)

        # Create a git repo to play with

        gitrepo = os.path.join(self.path, "repos", "test.git")

        repo = pygit2.init_repository(gitrepo, bare=True)

        newpath = tempfile.mkdtemp(prefix="pagure-fork-test")

        repopath = os.path.join(newpath, "test")

        clone_repo = pygit2.clone_repository(gitrepo, repopath)

        # Create a file in that git repo

        with open(os.path.join(repopath, "sources"), "w") as stream:

            stream.write("foo\n bar")

        clone_repo.index.add("sources")

        clone_repo.index.write()

        # Commits the files added

        tree = clone_repo.index.write_tree()

        author = pygit2.Signature("Alice Author", "alice@authors.tld")

        committer = pygit2.Signature("Cecil Committer", "cecil@committers.tld")

        clone_repo.create_commit(

            "refs/heads/master",  # the name of the reference to update

            author,

            committer,

            "Add sources file for testing",

            # binary string representing the tree object ID

            tree,

            # list of binary strings representing parents of the new commit

            [],

        )

        refname = "refs/heads/master:refs/heads/master"

        ori_remote = clone_repo.remotes[0]

        PagureRepo.push(ori_remote, refname)

        # Tag our first commit

        first_commit = repo.revparse_single("HEAD")

        tagger = pygit2.Signature("Alice Doe", "adoe@example.com", 12347, 0)

        repo.create_tag(

            "0.0.1",

            first_commit.oid.hex,

            pygit2.GIT_OBJ_COMMIT,

            tagger,

            "Release 0.0.1",

        )

        # Check tags

        output = self.app.get("/api/0/test/git/tags")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(data, {"tags": ["0.0.1"], "total_tags": 1})

        # Check tags with commits

        output = self.app.get("/api/0/test/git/tags?with_commits=True")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data["tags"]["0.0.1"] = "bb8fa2aa199da08d6085e1c9badc3d83d188d38c"

        self.assertDictEqual(

            data,

            {

                "tags": {"0.0.1": "bb8fa2aa199da08d6085e1c9badc3d83d188d38c"},

                "total_tags": 1,

            },

        )

        shutil.rmtree(newpath)

    def test_api_git_branches(self):

        """ Test the api_git_branches method of the flask api. """

        # Create a git repo to add branches to

        tests.create_projects(self.session)

        repo_path = os.path.join(self.path, "repos", "test.git")

        tests.add_content_git_repo(repo_path)

        new_repo_path = tempfile.mkdtemp(prefix="pagure-api-git-branches-test")

        clone_repo = pygit2.clone_repository(repo_path, new_repo_path)

        # Create two other branches based on master

        for branch in ["pats-win-49", "pats-win-51"]:

            clone_repo.create_branch(branch, clone_repo.head.peel())

            refname = "refs/heads/{0}:refs/heads/{0}".format(branch)

            PagureRepo.push(clone_repo.remotes[0], refname)

        # Check that the branches show up on the API

        output = self.app.get("/api/0/test/git/branches")

        # Delete the cloned git repo after the API call

        shutil.rmtree(new_repo_path)

        # Verify the API data

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(

            data,

            {

                "branches": ["master", "pats-win-49", "pats-win-51"],

                "total_branches": 3,

            },

        )

    def test_api_git_branches_empty_repo(self):

        """ Test the api_git_branches method of the flask api when the repo is

        empty.

        """

        # Create a git repo without any branches

        tests.create_projects(self.session)

        repo_base_path = os.path.join(self.path, "repos")

        tests.create_projects_git(repo_base_path)

        # Check that no branches show up on the API

        output = self.app.get("/api/0/test/git/branches")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(data, {"branches": [], "total_branches": 0})

    def test_api_git_branches_no_repo(self):

        """ Test the api_git_branches method of the flask api when there is no

        repo on a project.

        """

        tests.create_projects(self.session)

        output = self.app.get("/api/0/test/git/branches")

        self.assertEqual(output.status_code, 404)

    def test_api_git_urls(self):

        """ Test the api_project_git_urls method of the flask api.

        """

        tests.create_projects(self.session)

        output = self.app.get("/api/0/test/git/urls")

        self.assertEqual(output.status_code, 200)

        expected_rv = {

            "urls": {

                "git": "git://localhost.localdomain/test.git",

                "ssh": "ssh://git@localhost.localdomain/test.git",

            },

            "total_urls": 2,

        }

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(data, expected_rv)

    def test_api_git_urls_no_project(self):

        """ Test the api_project_git_urls method of the flask api when there is

        no project.

        """

        output = self.app.get("/api/0/test1234/git/urls")

        self.assertEqual(output.status_code, 404)

        expected_rv = {

            "error": "Project not found",

            "error_code": "ENOPROJECT",

        }

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(data, expected_rv)

    @patch.dict("pagure.config.config", {"PRIVATE_PROJECTS": True})

    def test_api_git_urls_private_project(self):

        """ Test the api_project_git_urls method of the flask api when the

        project is private.

        """

        tests.create_projects(self.session)

        tests.create_tokens(self.session)

        tests.create_tokens_acl(self.session, "aaabbbcccddd")

        headers = {"Authorization": "token aaabbbcccddd"}

        test_project = pagure.lib.query._get_project(self.session, "test")

        test_project.private = True

        self.session.add(test_project)

        self.session.commit()

        output = self.app.get("/api/0/test/git/urls", headers=headers)

        self.assertEqual(output.status_code, 200)

        expected_rv = {

            "urls": {

                "git": "git://localhost.localdomain/test.git",

                "ssh": "ssh://git@localhost.localdomain/test.git",

            },

            "total_urls": 2,

        }

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(data, expected_rv)

    @patch.dict("pagure.config.config", {"PRIVATE_PROJECTS": True})

    def test_api_git_urls_private_project_no_login(self):

        """ Test the api_project_git_urls method of the flask api when the

        project is private and the user is not logged in.

        """

        tests.create_projects(self.session)

        test_project = pagure.lib.query._get_project(self.session, "test")

        test_project.private = True

        self.session.add(test_project)

        self.session.commit()

        output = self.app.get("/api/0/test/git/urls")

        self.assertEqual(output.status_code, 404)

        expected_rv = {

            "error": "Project not found",

            "error_code": "ENOPROJECT",

        }

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(data, expected_rv)

    def test_api_projects_pattern(self):

        """ Test the api_projects method of the flask api. """

        tests.create_projects(self.session)

        output = self.app.get("/api/0/projects?pattern=test")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data["projects"][0]["date_created"] = "1436527638"

        data["projects"][0]["date_modified"] = "1436527638"

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": None,

                "page": 1,

                "pattern": "test",

                "per_page": 20,

                "short": False,

                "tags": [],

                "username": None,

            },

            "projects": [

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "test project #1",

                    "fullname": "test",

                    "url_path": "test",

                    "id": 1,

                    "milestones": {},

                    "name": "test",

                    "namespace": None,

                    "parent": None,

                    "priorities": {},

                    "tags": [],

                    "user": {"fullname": "PY C", "name": "pingou"},

                }

            ],

            "total_projects": 1,

        }

        self.assertDictEqual(data, expected_data)

    def test_api_projects_pattern_short(self):

        """ Test the api_projects method of the flask api. """

        tests.create_projects(self.session)

        output = self.app.get("/api/0/projects?pattern=te*&short=1")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": None,

                "page": 1,

                "pattern": "te*",

                "per_page": 20,

                "short": True,

                "tags": [],

                "username": None,

            },

            "projects": [

                {

                    "description": "test project #1",

                    "fullname": "test",

                    "name": "test",

                    "namespace": None,

                },

                {

                    "description": "test project #2",

                    "fullname": "test2",

                    "name": "test2",

                    "namespace": None,

                },

                {

                    "description": "namespaced test project",

                    "fullname": "somenamespace/test3",

                    "name": "test3",

                    "namespace": "somenamespace",

                },

            ],

            "total_projects": 3,

        }

        self.maxDiff = None

        self.assertDictEqual(data, expected_data)

    def test_api_projects_owner(self):

        """ Test the api_projects method of the flask api. """

        tests.create_projects(self.session)

        output = self.app.get("/api/0/projects?owner=foo")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": "foo",

                "page": 1,

                "pattern": None,

                "per_page": 20,

                "short": False,

                "tags": [],

                "username": None,

            },

            "projects": [],

            "total_projects": 0,

        }

        self.maxDiff = None

        self.assertDictEqual(data, expected_data)

    def test_api_projects_not_owner(self):

        """ Test the api_projects method of the flask api. """

        tests.create_projects(self.session)

        output = self.app.get("/api/0/projects?owner=!foo&short=1")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": "!foo",

                "page": 1,

                "pattern": None,

                "per_page": 20,

                "short": True,

                "tags": [],

                "username": None,

            },

            "projects": [

                {

                    "description": "test project #1",

                    "fullname": "test",

                    "name": "test",

                    "namespace": None,

                },

                {

                    "description": "test project #2",

                    "fullname": "test2",

                    "name": "test2",

                    "namespace": None,

                },

                {

                    "description": "namespaced test project",

                    "fullname": "somenamespace/test3",

                    "name": "test3",

                    "namespace": "somenamespace",

                },

            ],

            "total_projects": 3,

        }

        self.maxDiff = None

        self.assertDictEqual(data, expected_data)

    def test_api_projects(self):

        """ Test the api_projects method of the flask api. """

        tests.create_projects(self.session)

        # Check before adding

        repo = pagure.lib.query.get_authorized_project(self.session, "test")

        self.assertEqual(repo.tags, [])

        # Adding a tag

        output = pagure.lib.query.update_tags(

            self.session, repo, "infra", "pingou"

        )

        self.assertEqual(output, ["Project tagged with: infra"])

        # Check after adding

        repo = pagure.lib.query.get_authorized_project(self.session, "test")

        self.assertEqual(len(repo.tags), 1)

        self.assertEqual(repo.tags_text, ["infra"])

        # Check the API

        output = self.app.get("/api/0/projects?tags=inf")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        null = None

        del data["pagination"]

        self.assertDictEqual(

            data,

            {

                "total_projects": 0,

                "projects": [],

                "args": {

                    "fork": None,

                    "namespace": None,

                    "owner": None,

                    "page": 1,

                    "pattern": None,

                    "per_page": 20,

                    "short": False,

                    "tags": ["inf"],

                    "username": None,

                },

            },

        )

        output = self.app.get("/api/0/projects?tags=infra")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data["projects"][0]["date_created"] = "1436527638"

        data["projects"][0]["date_modified"] = "1436527638"

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": None,

                "page": 1,

                "pattern": None,

                "per_page": 20,

                "short": False,

                "tags": ["infra"],

                "username": None,

            },

            "projects": [

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "test project #1",

                    "fullname": "test",

                    "url_path": "test",

                    "id": 1,

                    "milestones": {},

                    "name": "test",

                    "namespace": None,

                    "parent": None,

                    "priorities": {},

                    "tags": ["infra"],

                    "user": {"fullname": "PY C", "name": "pingou"},

                }

            ],

            "total_projects": 1,

        }

        self.assertDictEqual(data, expected_data)

        output = self.app.get("/api/0/projects?owner=pingou")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data["projects"][0]["date_created"] = "1436527638"

        data["projects"][0]["date_modified"] = "1436527638"

        data["projects"][1]["date_created"] = "1436527638"

        data["projects"][1]["date_modified"] = "1436527638"

        data["projects"][2]["date_created"] = "1436527638"

        data["projects"][2]["date_modified"] = "1436527638"

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": "pingou",

                "page": 1,

                "pattern": None,

                "per_page": 20,

                "short": False,

                "tags": [],

                "username": None,

            },

            "projects": [

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "test project #1",

                    "fullname": "test",

                    "url_path": "test",

                    "id": 1,

                    "milestones": {},

                    "name": "test",

                    "namespace": None,

                    "parent": None,

                    "priorities": {},

                    "tags": ["infra"],

                    "user": {"fullname": "PY C", "name": "pingou"},

                },

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "test project #2",

                    "fullname": "test2",

                    "url_path": "test2",

                    "id": 2,

                    "milestones": {},

                    "name": "test2",

                    "namespace": None,

                    "parent": None,

                    "priorities": {},

                    "tags": [],

                    "user": {"fullname": "PY C", "name": "pingou"},

                },

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "namespaced test project",

                    "fullname": "somenamespace/test3",

                    "url_path": "somenamespace/test3",

                    "id": 3,

                    "milestones": {},

                    "name": "test3",

                    "namespace": "somenamespace",

                    "parent": None,

                    "priorities": {},

                    "tags": [],

                    "user": {"fullname": "PY C", "name": "pingou"},

                },

            ],

            "total_projects": 3,

        }

        self.assertDictEqual(data, expected_data)

        output = self.app.get("/api/0/projects?username=pingou")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data["projects"][0]["date_created"] = "1436527638"

        data["projects"][0]["date_modified"] = "1436527638"

        data["projects"][1]["date_created"] = "1436527638"

        data["projects"][1]["date_modified"] = "1436527638"

        data["projects"][2]["date_created"] = "1436527638"

        data["projects"][2]["date_modified"] = "1436527638"

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": None,

                "page": 1,

                "pattern": None,

                "per_page": 20,

                "short": False,

                "tags": [],

                "username": "pingou",

            },

            "projects": [

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "test project #1",

                    "fullname": "test",

                    "url_path": "test",

                    "id": 1,

                    "milestones": {},

                    "name": "test",

                    "namespace": None,

                    "parent": None,

                    "priorities": {},

                    "tags": ["infra"],

                    "user": {"fullname": "PY C", "name": "pingou"},

                },

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "test project #2",

                    "fullname": "test2",

                    "url_path": "test2",

                    "id": 2,

                    "milestones": {},

                    "name": "test2",

                    "namespace": None,

                    "parent": None,

                    "priorities": {},

                    "tags": [],

                    "user": {"fullname": "PY C", "name": "pingou"},

                },

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "namespaced test project",

                    "fullname": "somenamespace/test3",

                    "url_path": "somenamespace/test3",

                    "id": 3,

                    "milestones": {},

                    "name": "test3",

                    "namespace": "somenamespace",

                    "parent": None,

                    "priorities": {},

                    "tags": [],

                    "user": {"fullname": "PY C", "name": "pingou"},

                },

            ],

            "total_projects": 3,

        }

        self.assertDictEqual(data, expected_data)

        output = self.app.get("/api/0/projects?username=pingou&tags=infra")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data["projects"][0]["date_created"] = "1436527638"

        data["projects"][0]["date_modified"] = "1436527638"

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "namespace": None,

                "owner": None,

                "page": 1,

                "pattern": None,

                "per_page": 20,

                "short": False,

                "tags": ["infra"],

                "username": "pingou",

            },

            "projects": [

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "test project #1",

                    "fullname": "test",

                    "url_path": "test",

                    "id": 1,

                    "milestones": {},

                    "name": "test",

                    "namespace": None,

                    "parent": None,

                    "priorities": {},

                    "tags": ["infra"],

                    "user": {"fullname": "PY C", "name": "pingou"},

                }

            ],

            "total_projects": 1,

        }

        self.assertDictEqual(data, expected_data)

        output = self.app.get("/api/0/projects?namespace=somenamespace")

        self.assertEqual(output.status_code, 200)

        data = json.loads(output.get_data(as_text=True))

        data["projects"][0]["date_created"] = "1436527638"

        data["projects"][0]["date_modified"] = "1436527638"

        del data["pagination"]

        expected_data = {

            "args": {

                "fork": None,

                "owner": None,

                "page": 1,

                "namespace": "somenamespace",

                "per_page": 20,

                "pattern": None,

                "short": False,

                "tags": [],

                "username": None,

            },

            "projects": [

                {

                    "access_groups": {"admin": [], "commit": [], "ticket": []},

                    "access_users": {

                        "admin": [],

                        "commit": [],

                        "owner": ["pingou"],

                        "ticket": [],

                    },

                    "close_status": [

                        "Invalid",

                        "Insufficient data",

                        "Fixed",

                        "Duplicate",

                    ],

                    "custom_keys": [],

                    "date_created": "1436527638",

                    "date_modified": "1436527638",

                    "description": "namespaced test project",

                    "fullname": "somenamespace/test3",

                    "url_path": "somenamespace/test3",

                    "id": 3,

                    "milestones": {},

                    "name": "test3",

                    "namespace": "somenamespace",

                    "parent": None,

                    "priorities": {},

                    "tags": [],

                    "user": {"fullname": "PY C", "name": "pingou"},

                }

            ],

            "total_projects": 1,

        }

        self.assertDictEqual(data, expected_data)

    def test_api_project(self):

        """ Test the api_project method of the flask api. """

        tests.create_projects(self.session)

        # Check before adding

        repo = pagure.lib.query.get_authorized_project(self.session, "test")

        self.assertEqual(repo.tags, [])

        # Adding a tag

        output = pagure.lib.query.update_tags(

            self.session, repo, "infra", "pingou"

        )

        self.assertEqual(output, ["Project tagged with: infra"])

        # Check after adding

        repo = pagure.lib.query.get_authorized_project(self.session, "test")

        self.assertEqual(len(repo.tags), 1)

        self.assertEqual(repo.tags_text, ["infra"])

        # Check the API

        # Non-existing project

        output = self.app.get("/api/0/random")

        self.assertEqual(output.status_code, 404)

        data = json.loads(output.get_data(as_text=True))

        self.assertDictEqual(