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

"""
 (c) 2015 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>

"""

__requires__ = ['SQLAlchemy >= 0.8']
import pkg_resources

import json
import unittest
import shutil
import sys
import os
import tempfile
import pygit2
from mock import patch

sys.path.insert(0, os.path.join(os.path.dirname(
    os.path.abspath(__file__)), '..'))

import pagure.lib.git
import tests

from pagure.lib.repo import PagureRepo

class PagureLibGittests(tests.Modeltests):
    """ Tests for pagure.lib.git """

    def setUp(self):
        """ Set up the environnment, ran before every tests. """
        super(PagureLibGittests, self).setUp()

        pagure.lib.git.SESSION = self.session
        pagure.APP.config['GIT_FOLDER'] = os.path.join(
            tests.HERE, 'repos')
        pagure.APP.config['FORK_FOLDER'] = os.path.join(
            tests.HERE, 'forks')
        pagure.APP.config['TICKETS_FOLDER'] = os.path.join(
            tests.HERE, 'tickets')
        pagure.APP.config['DOCS_FOLDER'] = os.path.join(
            tests.HERE, 'docs')
        pagure.APP.config['REQUESTS_FOLDER'] = os.path.join(
            tests.HERE, 'requests')

    def test_write_gitolite_acls(self):
        """ Test the write_gitolite_acls function of pagure.lib.git. """
        tests.create_projects(self.session)

        repo = pagure.lib.get_project(self.session, 'test')
        # Add an user to a project
        msg = pagure.lib.add_user_to_project(
            session=self.session,
            project=repo,
            new_user='foo',
            user='pingou',
        )
        self.session.commit()
        self.assertEqual(msg, 'User added')
        # Add a forked project
        item = pagure.lib.model.Project(
            user_id=1,  # pingou
            name='test3',
            description='test project #2',
            parent_id=1,
            hook_token='aaabbbvvv',
        )
        self.session.add(item)
        self.session.commit()

        outputconf = os.path.join(tests.HERE, 'test_gitolite.conf')

        pagure.lib.git.write_gitolite_acls(self.session, outputconf)

        self.assertTrue(os.path.exists(outputconf))

        with open(outputconf) as stream:
            data = stream.read()

        exp = """
repo test
  R   = @all
  RW+ = pingou
  RW+ = foo

repo docs/test
  R   = @all
  RW+ = pingou
  RW+ = foo

repo tickets/test
  RW+ = pingou
  RW+ = foo

repo requests/test
  RW+ = pingou
  RW+ = foo

repo test2
  R   = @all
  RW+ = pingou

repo docs/test2
  R   = @all
  RW+ = pingou

repo tickets/test2
  RW+ = pingou

repo requests/test2
  RW+ = pingou

repo forks/pingou/test3
  R   = @all
  RW+ = pingou

repo docs/forks/pingou/test3
  R   = @all
  RW+ = pingou

repo tickets/forks/pingou/test3
  RW+ = pingou

repo requests/forks/pingou/test3
  RW+ = pingou

"""
        #print data
        self.assertEqual(data, exp)

        os.unlink(outputconf)
        self.assertFalse(os.path.exists(outputconf))

    def test_write_gitolite_acls_groups(self):
        """ Test the write_gitolite_acls function of pagure.lib.git with
        groups.
        """
        tests.create_projects(self.session)

        repo = pagure.lib.get_project(self.session, 'test')

        # Add a couple of groups
        msg = pagure.lib.add_group(
            self.session,
            group_name='sysadmin',
            group_type='user',
            user='pingou',
            is_admin=False,
            blacklist=[],
        )
        self.session.commit()
        self.assertEqual(msg, 'User `pingou` added to the group `sysadmin`.')
        msg = pagure.lib.add_group(
            self.session,
            group_name='devs',
            group_type='user',
            user='pingou',
            is_admin=False,
            blacklist=[],
        )
        self.session.commit()
        self.assertEqual(msg, 'User `pingou` added to the group `devs`.')

        # Associate these groups to a project
        msg = pagure.lib.add_group_to_project(
            session=self.session,
            project=repo,
            new_group='sysadmin',
            user='pingou',
        )
        self.session.commit()
        self.assertEqual(msg, 'Group added')
        msg = pagure.lib.add_group_to_project(
            session=self.session,
            project=repo,
            new_group='devs',
            user='pingou',
        )
        self.session.commit()
        self.assertEqual(msg, 'Group added')

        # Add an user to a project
        msg = pagure.lib.add_user_to_project(
            session=self.session,
            project=repo,
            new_user='foo',
            user='pingou',
        )
        self.session.commit()
        self.assertEqual(msg, 'User added')
        # Add a forked project
        item = pagure.lib.model.Project(
            user_id=1,  # pingou
            name='test2',
            description='test project #2',
            parent_id=1,
            hook_token='aaabbbvvv',
        )
        self.session.add(item)
        self.session.commit()

        outputconf = os.path.join(tests.HERE, 'test_gitolite.conf')

        pagure.lib.git.write_gitolite_acls(self.session, outputconf)

        self.assertTrue(os.path.exists(outputconf))

        with open(outputconf) as stream:
            data = stream.read()

        exp = """@sysadmin   = pingou
@devs   = pingou

repo test
  R   = @all
  RW+ = @sysadmin @devs
  RW+ = pingou
  RW+ = foo

repo docs/test
  R   = @all
  RW+ = @sysadmin @devs
  RW+ = pingou
  RW+ = foo

repo tickets/test
  RW+ = @sysadmin @devs
  RW+ = pingou
  RW+ = foo

repo requests/test
  RW+ = @sysadmin @devs
  RW+ = pingou
  RW+ = foo

repo test2
  R   = @all
  RW+ = pingou

repo docs/test2
  R   = @all
  RW+ = pingou

repo tickets/test2
  RW+ = pingou

repo requests/test2
  RW+ = pingou

repo forks/pingou/test2
  R   = @all
  RW+ = pingou

repo docs/forks/pingou/test2
  R   = @all
  RW+ = pingou

repo tickets/forks/pingou/test2
  RW+ = pingou

repo requests/forks/pingou/test2
  RW+ = pingou

"""
        #print data
        self.assertEqual(data.split('\n'), exp.split('\n'))

        os.unlink(outputconf)
        self.assertFalse(os.path.exists(outputconf))

    def test_commit_to_patch(self):
        """ Test the commit_to_patch function of pagure.lib.git. """
        # Create a git repo to play with
        self.gitrepo = os.path.join(tests.HERE, 'test_repo.git')
        os.makedirs(self.gitrepo)
        repo = pygit2.init_repository(self.gitrepo)

        # Create a file in that git repo
        with open(os.path.join(self.gitrepo, 'sources'), 'w') as stream:
            stream.write('foo\n bar')
        repo.index.add('sources')
        repo.index.write()

        # Commits the files added
        tree = repo.index.write_tree()
        author = pygit2.Signature(
            'Alice Author', 'alice@authors.tld')
        committer = pygit2.Signature(
            'Cecil Committer', 'cecil@committers.tld')
        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
            []
        )

        first_commit = repo.revparse_single('HEAD')

        # Edit the sources file again
        with open(os.path.join(self.gitrepo, 'sources'), 'w') as stream:
            stream.write('foo\n bar\nbaz\n boose')
        repo.index.add('sources')
        repo.index.write()

        # Commits the files added
        tree = repo.index.write_tree()
        author = pygit2.Signature(
            'Alice Author', 'alice@authors.tld')
        committer = pygit2.Signature(
            'Cecil Committer', 'cecil@committers.tld')
        repo.create_commit(
            'refs/heads/master',  # the name of the reference to update
            author,
            committer,
            'Add baz and boose to the sources\n\n There are more objects to '
            'consider',
            # binary string representing the tree object ID
            tree,
            # list of binary strings representing parents of the new commit
            [first_commit.oid.hex]
        )

        second_commit = repo.revparse_single('HEAD')

        # Generate a patch for 2 commits
        patch = pagure.lib.git.commit_to_patch(
            repo, [first_commit, second_commit])
        exp = """Mon Sep 17 00:00:00 2001
From: Alice Author <alice@authors.tld>
Subject: [PATCH 1/2] Add sources file for testing

---

diff --git a/sources b/sources
new file mode 100644
index 0000000..9f44358
--- /dev/null
+++ b/sources
@@ -0,0 +1,2 @@
+foo
+ bar
\ No newline at end of file

Mon Sep 17 00:00:00 2001
From: Alice Author <alice@authors.tld>
Subject: [PATCH 2/2] Add baz and boose to the sources

 There are more objects to consider
---

diff --git a/sources b/sources
index 9f44358..2a552bb 100644
--- a/sources
+++ b/sources
@@ -1,2 +1,4 @@
 foo
- bar
\ No newline at end of file
+ bar
+baz
+ boose
\ No newline at end of file

"""
        npatch = []
        for row in patch.split('\n'):
            if row.startswith('Date:'):
                continue
            if row.startswith('From '):
                row = row.split(' ', 2)[2]
            npatch.append(row)

        patch = '\n'.join(npatch)
        self.assertEqual(patch, exp)

        # Generate a patch for a single commit
        patch = pagure.lib.git.commit_to_patch(repo, second_commit)
        exp = """Mon Sep 17 00:00:00 2001
From: Alice Author <alice@authors.tld>
Subject: Add baz and boose to the sources

 There are more objects to consider
---

diff --git a/sources b/sources
index 9f44358..2a552bb 100644
--- a/sources
+++ b/sources
@@ -1,2 +1,4 @@
 foo
- bar
\ No newline at end of file
+ bar
+baz
+ boose
\ No newline at end of file

"""
        npatch = []
        for row in patch.split('\n'):
            if row.startswith('Date:'):
                continue
            if row.startswith('From '):
                row = row.split(' ', 2)[2]
            npatch.append(row)

        patch = '\n'.join(npatch)
        self.assertEqual(patch, exp)

    @patch('pagure.lib.notify.send_email')
    def test_update_git(self, email_f):
        """ Test the update_git of pagure.lib.git. """
        email_f.return_value = True

        # Create project
        item = pagure.lib.model.Project(
            user_id=1,  # pingou
            name='test_ticket_repo',
            description='test project for ticket',
            hook_token='aaabbbwww',
        )
        self.session.add(item)
        self.session.commit()

        # Create repo
        self.gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        os.makedirs(self.gitrepo)
        repo_obj = pygit2.init_repository(self.gitrepo, bare=True)

        repo = pagure.lib.get_project(self.session, 'test_ticket_repo')
        # Create an issue to play with
        msg = pagure.lib.new_issue(
            session=self.session,
            repo=repo,
            title='Test issue',
            content='We should work on this',
            user='pingou',
            ticketfolder=tests.HERE
        )
        self.assertEqual(msg.title, 'Test issue')
        issue = pagure.lib.search_issues(self.session, repo, issueid=1)
        pagure.lib.git.update_git(issue, repo, tests.HERE)

        repo = pygit2.Repository(self.gitrepo)
        commit = repo.revparse_single('HEAD')

        # Use patch to validate the repo
        patch = pagure.lib.git.commit_to_patch(repo, commit)
        exp = """Mon Sep 17 00:00:00 2001
From: pagure <pagure>
Subject: Updated issue <hash>: Test issue

---

diff --git a/123 b/456
new file mode 100644
index 0000000..60f7480
--- /dev/null
+++ b/456
@@ -0,0 +1,24 @@
+{
+    "assignee": null,
+    "blocks": [],
+    "closed_at": null,
+    "comments": [],
+    "content": "We should work on this",
+    "date_created": null,
+    "depends": [],
+    "id": 1,
+    "priority": null,
+    "private": false,
+    "status": "Open",
+    "tags": [],
+    "title": "Test issue",
+    "user": {
+        "default_email": "bar@pingou.com",
+        "emails": [
+            "bar@pingou.com",
+            "foo@pingou.com"
+        ],
+        "fullname": "PY C",
+        "name": "pingou"
+    }
+}
\ No newline at end of file

"""
        npatch = []
        for row in patch.split('\n'):
            if row.startswith('Date:'):
                continue
            elif row.startswith('From '):
                row = row.split(' ', 2)[2]
            elif row.startswith('diff --git '):
                row = row.split(' ')
                row[2] = 'a/123'
                row[3] = 'b/456'
                row = ' '.join(row)
            elif 'Updated issue' in row:
                row = row.split()
                row[3] = '<hash>:'
                row = ' '.join(row)
            elif 'date_created' in row:
                t = row.split(': ')[0]
                row = '%s: null,' % t
            elif 'closed_at' in row:
                t = row.split(': ')[0]
                row = '%s: null,' % t
            elif row.startswith('index 00'):
                row = 'index 0000000..60f7480'
            elif row.startswith('+++ b/'):
                row = '+++ b/456'
            npatch.append(row)
        patch = '\n'.join(npatch)
        #print patch
        self.assertEqual(patch, exp)

        # Test again after adding a comment
        msg = pagure.lib.add_issue_comment(
            session=self.session,
            issue=issue,
            comment='Hey look a comment!',
            user='foo',
            ticketfolder=tests.HERE
        )
        self.session.commit()
        self.assertEqual(msg, 'Comment added')

        # Use patch to validate the repo
        repo = pygit2.Repository(self.gitrepo)
        commit = repo.revparse_single('HEAD')
        patch = pagure.lib.git.commit_to_patch(repo, commit)
        exp = """Mon Sep 17 00:00:00 2001
From: pagure <pagure>
Subject: Updated issue <hash>: Test issue

---

diff --git a/123 b/456
index 458821a..77674a8
--- a/123
+++ b/456
@@ -2,7 +2,25 @@
     "assignee": null,
     "blocks": [],
     "closed_at": null,
-    "comments": [],
+    "comments": [
+        {
+            "comment": "Hey look a comment!",
+            "date_created": null,
+            "edited_on": null,
+            "editor": null,
+            "id": 1,
+            "notification": false,
+            "parent": null,
+            "user": {
+                "default_email": "foo@bar.com",
+                "emails": [
+                    "foo@bar.com"
+                ],
+                "fullname": "foo bar",
+                "name": "foo"
+            }
+        }
+    ],
     "content": "We should work on this",
     "date_created": null,
     "depends": [],

"""
        npatch = []
        for row in patch.split('\n'):
            if row.startswith('Date:'):
                continue
            elif row.startswith('From '):
                row = row.split(' ', 2)[2]
            elif row.startswith('diff --git '):
                row = row.split(' ')
                row[2] = 'a/123'
                row[3] = 'b/456'
                row = ' '.join(row)
            elif 'Updated issue' in row:
                row = row.split()
                row[3] = '<hash>:'
                row = ' '.join(row)
            elif 'date_created' in row:
                t = row.split(': ')[0]
                row = '%s: null,' % t
            elif 'closed_at' in row:
                t = row.split(': ')[0]
                row = '%s: null,' % t
            elif row.startswith('index'):
                row = 'index 458821a..77674a8'
            elif row.startswith('--- a/'):
                row = '--- a/123'
            elif row.startswith('+++ b/'):
                row = '+++ b/456'
            npatch.append(row)
        patch = '\n'.join(npatch)
        #print patch
        self.assertEqual(patch, exp)

    def test_clean_git(self):
        """ Test the clean_git method of pagure.lib.git. """
        pagure.lib.git.clean_git(None, None, None)

        self.test_update_git()

        gitpath = os.path.join(tests.HERE, 'test_ticket_repo.git')
        gitrepo = pygit2.init_repository(gitpath, bare=True)

        # Get the uid of the ticket created
        commit = gitrepo.revparse_single('HEAD')
        patch = pagure.lib.git.commit_to_patch(gitrepo, commit)
        hash_file = None
        for row in patch.split('\n'):
            if row.startswith('+++ b/'):
                hash_file = row.split('+++ b/')[-1]
                break

        # The only file in git is the one of that ticket
        files = [entry.name for entry in commit.tree]
        self.assertEqual(files, [hash_file])

        repo = pagure.lib.get_project(self.session, 'test_ticket_repo')
        issue = pagure.lib.search_issues(self.session, repo, issueid=1)
        pagure.lib.git.clean_git(issue, repo, tests.HERE)

        # No more files in the git repo
        commit = gitrepo.revparse_single('HEAD')
        files = [entry.name for entry in commit.tree]
        self.assertEqual(files, [])

    @patch('pagure.lib.notify.send_email')
    def test_update_git_requests(self, email_f):
        """ Test the update_git of pagure.lib.git for pull-requests. """
        email_f.return_value = True

        # Create project
        item = pagure.lib.model.Project(
            user_id=1,  # pingou
            name='test_ticket_repo',
            description='test project for ticket',
            hook_token='aaabbbxxx',
        )
        self.session.add(item)
        self.session.commit()

        # Create repo
        self.gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        os.makedirs(self.gitrepo)
        repo_obj = pygit2.init_repository(self.gitrepo, bare=True)

        repo = pagure.lib.get_project(self.session, 'test_ticket_repo')
        # Create an issue to play with
        req = pagure.lib.new_pull_request(
            session=self.session,
            repo_from=repo,
            branch_from='feature',
            repo_to=repo,
            branch_to='master',
            title='test PR',
            user='pingou',
            requestfolder=tests.HERE,
            requestuid='foobar',
            requestid=None,
            status='Open',
            notify=True
        )
        self.assertEqual(req.id, 1)
        self.assertEqual(req.title, 'test PR')

        request = repo.requests[0]
        self.assertEqual(request.title, 'test PR')
        pagure.lib.git.update_git(request, request.project, tests.HERE)

        repo = pygit2.Repository(self.gitrepo)
        commit = repo.revparse_single('HEAD')

        # Use patch to validate the repo
        patch = pagure.lib.git.commit_to_patch(repo, commit)
        exp = """Mon Sep 17 00:00:00 2001
From: pagure <pagure>
Subject: Updated pull-request <hash>: test PR

---

diff --git a/123 b/456
new file mode 100644
index 0000000..60f7480
--- /dev/null
+++ b/456
@@ -0,0 +1,83 @@
+{
+    "assignee": null,
+    "branch": "master",
+    "branch_from": "feature",
+    "closed_at": null,
+    "closed_by": null,
+    "comments": [],
+    "commit_start": null,
+    "commit_stop": null,
+    "date_created": null,
+    "id": 1,
+    "initial_comment": null,
+    "project": {
+        "date_created": null,
+        "description": "test project for ticket",
+        "id": 1,
+        "name": "test_ticket_repo",
+        "parent": null,
+        "priorities": {},
+        "settings": {
+            "Enforce_signed-off_commits_in_pull-request": false,
+            "Minimum_score_to_merge_pull-request": -1,
+            "Only_assignee_can_merge_pull-request": false,
+            "Web-hooks": null,
+            "always_merge": false,
+            "issue_tracker": true,
+            "project_documentation": false,
+            "pull_requests": true
+        },
+        "tags": [],
+        "user": {
+            "default_email": "bar@pingou.com",
+            "emails": [
+                "bar@pingou.com",
+                "foo@pingou.com"
+            ],
+            "fullname": "PY C",
+            "name": "pingou"
+        }
+    },
+    "remote_git": null,
+    "repo_from": {
+        "date_created": null,
+        "description": "test project for ticket",
+        "id": 1,
+        "name": "test_ticket_repo",
+        "parent": null,
+        "priorities": {},
+        "settings": {
+            "Enforce_signed-off_commits_in_pull-request": false,
+            "Minimum_score_to_merge_pull-request": -1,
+            "Only_assignee_can_merge_pull-request": false,
+            "Web-hooks": null,
+            "always_merge": false,
+            "issue_tracker": true,
+            "project_documentation": false,
+            "pull_requests": true
+        },
+        "tags": [],
+        "user": {
+            "default_email": "bar@pingou.com",
+            "emails": [
+                "bar@pingou.com",
+                "foo@pingou.com"
+            ],
+            "fullname": "PY C",
+            "name": "pingou"
+        }
+    },
+    "status": "Open",
+    "title": "test PR",
+    "uid": "foobar",
+    "updated_on": null,
+    "user": {
+        "default_email": "bar@pingou.com",
+        "emails": [
+            "bar@pingou.com",
+            "foo@pingou.com"
+        ],
+        "fullname": "PY C",
+        "name": "pingou"
+    }
+}
\ No newline at end of file

"""
        npatch = []
        for row in patch.split('\n'):
            if row.startswith('Date:'):
                continue
            elif row.startswith('From '):
                row = row.split(' ', 2)[2]
            elif row.startswith('diff --git '):
                row = row.split(' ')
                row[2] = 'a/123'
                row[3] = 'b/456'
                row = ' '.join(row)
            elif 'Updated pull-request' in row:
                row = row.split()
                row[3] = '<hash>:'
                row = ' '.join(row)
            elif 'date_created' in row:
                t = row.split(': ')[0]
                row = '%s: null,' % t
            elif 'updated_on' in row:
                t = row.split(': ')[0]
                row = '%s: null,' % t
            elif row.startswith('index 00'):
                row = 'index 0000000..60f7480'
            elif row.startswith('+++ b/'):
                row = '+++ b/456'
            npatch.append(row)
        patch = '\n'.join(npatch)
        #print patch
        self.assertEqual(patch, exp)

    def test_update_ticket_from_git(self):
        """ Test the update_ticket_from_git method from pagure.lib.git. """
        tests.create_projects(self.session)

        repo = pagure.lib.get_project(self.session, 'test')

        # Before
        self.assertEqual(len(repo.issues), 0)
        self.assertEqual(repo.issues, [])

        data = {
            "status": "Open", "title": "foo", "comments": [],
            "content": "bar", "date_created": "1426500263",
            "user": {
                "name": "pingou", "emails": ["pingou@fedoraproject.org"]},
        }

        self.assertRaises(
            pagure.exceptions.PagureException,
            pagure.lib.git.update_ticket_from_git,
            self.session,
            reponame='foobar',
            username=None,
            issue_uid='foobar',
            json_data=data
        )

        pagure.lib.git.update_ticket_from_git(
            self.session, reponame='test', username=None,
            issue_uid='foobar', json_data=data
        )
        self.session.commit()

        # After 1 insertion
        self.assertEqual(len(repo.issues), 1)
        self.assertEqual(repo.issues[0].id, 1)
        self.assertEqual(repo.issues[0].uid, 'foobar')
        self.assertEqual(repo.issues[0].title, 'foo')
        self.assertEqual(repo.issues[0].depends_text, [])
        self.assertEqual(repo.issues[0].blocks_text, [])

        data["title"] = "fake issue for tests"
        pagure.lib.git.update_ticket_from_git(
            self.session, reponame='test', username=None,
            issue_uid='foobar', json_data=data
        )
        self.session.commit()

        # After edit
        self.assertEqual(len(repo.issues), 1)
        self.assertEqual(repo.issues[0].id, 1)
        self.assertEqual(repo.issues[0].uid, 'foobar')
        self.assertEqual(repo.issues[0].title, 'fake issue for tests')
        self.assertEqual(repo.issues[0].depends_text, [])
        self.assertEqual(repo.issues[0].blocks_text, [])

        data = {
            "status": "Open", "title": "Rename pagure", "private": False,
            "content": "This is too much of a conflict with the book",
            "user": {
                "fullname": "Pierre-YvesChibon",
                "name": "pingou",
                "default_email": "pingou@fedoraproject.org",
                "emails": ["pingou@fedoraproject.org"]
            },
            "id": 20,
            "blocks": [1],
            "depends": [3, 4],
            "date_created": "1426595224",
            "comments": [
                {
                    "comment": "Nirik:\r\n\r\n- sourceforge++ \r\n- "
                    "gitmaker\r\n- mastergit \r\n- hostomatic\r\n- "
                    "gitcorp\r\n- git-keiretsu \r\n- gitbuffet\r\n- "
                    "cogitator\r\n- cogitate\r\n\r\nrandomuser:\r\n\r\n- "
                    "COLLABORATRON5000\r\n- git-sm\u00f6rg\u00e5sbord\r\n- "
                    "thislittlegittywenttomarket\r\n- git-o-rama\r\n- "
                    "gitsundheit",
                    "date_created": "1426595224", "id": 250, "parent": None,
                    "user": {
                        "fullname": "Pierre-YvesChibon",
                        "name": "pingou",
                        "default_email": "pingou@fedoraproject.org",
                        "emails": ["pingou@fedoraproject.org"]
                    }
                },
                {
                    "comment": "Nirik:\r\n\r\n- sourceforge++ \r\n- "
                    "gitmaker\r\n- mastergit \r\n- hostomatic\r\n- "
                    "gitcorp\r\n- git-keiretsu \r\n- gitbuffet\r\n- "
                    "cogitator\r\n- cogitate\r\n\r\nrandomuser:\r\n\r\n- "
                    "COLLABORATRON5000\r\n- git-sm\u00f6rg\u00e5sbord\r\n- "
                    "thislittlegittywenttomarket\r\n- git-o-rama\r\n- "
                    "gitsundheit",
                    "date_created": "1426595340", "id": 324, "parent": None,
                    "user": {
                        "fullname": "Ralph Bean",
                        "name": "ralph",
                        "default_email": "ralph@fedoraproject.org",
                        "emails": ["ralph@fedoraproject.org"]
                    }
                }
            ]
        }

        pagure.lib.git.update_ticket_from_git(
            self.session, reponame='test', username=None,
            issue_uid='foobar2', json_data=data
        )

        # After second insertion
        self.assertEqual(len(repo.issues), 2)
        self.assertEqual(repo.issues[0].uid, 'foobar')
        self.assertEqual(repo.issues[0].title, 'fake issue for tests')
        self.assertEqual(repo.issues[0].depends_text, [20])
        self.assertEqual(repo.issues[0].blocks_text, [])
        # New one
        self.assertEqual(repo.issues[1].uid, 'foobar2')
        self.assertEqual(repo.issues[1].title, 'Rename pagure')
        self.assertEqual(repo.issues[1].depends_text, [])
        self.assertEqual(repo.issues[1].blocks_text, [1])

    def test_update_request_from_git(self):
        """ Test the update_request_from_git method from pagure.lib.git. """
        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(tests.HERE, 'repos'))

        repo = pagure.lib.get_project(self.session, 'test')

        # Before
        self.assertEqual(len(repo.requests), 0)
        self.assertEqual(repo.requests, [])

        data = {
            "status": True,
            "uid": "d4182a2ac2d541d884742d3037c26e56",
            "project": {
                "parent": None,
                "settings": {
                    "issue_tracker": True,
                    "project_documentation": True,
                    "pull_requests": True,
                },
                "name": "test",
                "date_created": "1426500194",
                "tags": [],
                "user": {
                    "fullname": "Pierre-YvesChibon",
                    "name": "pingou",
                    "default_email": "pingou@fedoraproject.org",
                    "emails": [
                        "pingou@fedoraproject.org"
                    ]
                },
                "id": 1,
                "description": "test project"
            },
            "commit_stop": "eface8e13bc2a08a3fb22af9a72a8c90e36b8b89",
            "user": {
                "fullname": "Pierre-YvesChibon",
                "name": "pingou",
                "default_email": "pingou@fedoraproject.org",
                "emails": ["pingou@fedoraproject.org"]
            },
            "id": 7,
            "comments": [
                {
                    "comment": "really?",
                    "user": {
                        "fullname": "Pierre-YvesChibon",
                        "name": "pingou",
                        "default_email": "pingou@fedoraproject.org",
                        "emails": ["pingou@fedoraproject.org"]
                    },
                    "parent": None,
                    "date_created": "1426843778",
                    "commit": "fa72f315373ec5f98f2b08c8ffae3645c97aaad2",
                    "line": 5,
                    "id": 1,
                    "filename": "test"
                },
                {
                    "comment": "Again ?",
                    "user": {
                        "fullname": "Pierre-YvesChibon",
                        "name": "pingou",
                        "default_email": "pingou@fedoraproject.org",
                        "emails": [
                            "pingou@fedoraproject.org"
                        ]
                    },
                    "parent": None,
                    "date_created": "1426866781",
                    "commit": "94ebaf900161394059478fd88aec30e59092a1d7",
                    "line": 5,
                    "id": 2,
                    "filename": "test2"
                },
                {
                    "comment": "Should be fine in fact",
                    "user": {
                        "fullname": "Pierre-YvesChibon",
                        "name": "pingou",
                        "default_email": "pingou@fedoraproject.org",
                        "emails": [
                            "pingou@fedoraproject.org"
                        ]
                    },
                    "parent": None,
                    "date_created": "1426866950",
                    "commit": "94ebaf900161394059478fd88aec30e59092a1d7",
                    "line": 5,
                    "id": 3,
                    "filename": "test2"
                }
            ],
            "branch_from": "master",
            "title": "test request",
            "commit_start": "788efeaaf86bde8618f594a8181abb402e1dd904",
            "repo_from": {
                "parent": {
                    "parent": None,
                    "name": "test",
                    "date_created": "1426500194",
                    "tags": [],
                    "user": {
                        "fullname": "Pierre-YvesChibon",
                        "name": "pingou",
                        "default_email": "pingou@fedoraproject.org",
                        "emails": [
                            "pingou@fedoraproject.org"
                        ]
                    },
                    "settings": {
                        "issue_tracker": True,
                        "project_documentation": True,
                        "pull_requests": True,
                    },
                    "id": 1,
                    "description": "test project"
                },
                "settings": {
                    "issue_tracker": True,
                    "project_documentation": True,
                    "pull_requests": True,
                },
                "name": "test",
                "date_created": "1426843440",
                "tags": [],
                "user": {
                    "fullname": "fake user",
                    "name": "fake",
                    "default_email": "fake@fedoraproject.org",
                    "emails": [
                        "fake@fedoraproject.org"
                    ]
                },
                "id": 6,
                "description": "test project"
            },
            "branch": "master",
            "date_created": "1426843732"
        }

        self.assertRaises(
            pagure.exceptions.PagureException,
            pagure.lib.git.update_request_from_git,
            self.session,
            reponame='foobar',
            username=None,
            request_uid='d4182a2ac2d541d884742d3037c26e56',
            json_data=data,
            gitfolder=tests.HERE,
            docfolder=os.path.join(tests.HERE, 'docs'),
            ticketfolder=os.path.join(tests.HERE, 'tickets'),
            requestfolder=os.path.join(tests.HERE, 'requests')
        )

        pagure.lib.git.update_request_from_git(
            self.session,
            reponame='test',
            username=None,
            request_uid='d4182a2ac2d541d884742d3037c26e56',
            json_data=data,
            gitfolder=tests.HERE,
            docfolder=os.path.join(tests.HERE, 'docs'),
            ticketfolder=os.path.join(tests.HERE, 'tickets'),
            requestfolder=os.path.join(tests.HERE, 'requests')
        )
        self.session.commit()

        # After 1 st insertion
        self.assertEqual(len(repo.requests), 1)
        self.assertEqual(repo.requests[0].id, 7)
        self.assertEqual(
            repo.requests[0].uid, 'd4182a2ac2d541d884742d3037c26e56')
        self.assertEqual(repo.requests[0].title, 'test request')
        self.assertEqual(len(repo.requests[0].comments), 3)

        data = {
            "status": True,
            "uid": "d4182a2ac2d541d884742d3037c26e57",
            "project": {
                "parent": None,
                "name": "test",
                "date_created": "1426500194",
                "tags": [],
                "user": {
                    "fullname": "Pierre-YvesChibon",
                    "name": "pingou",
                    "default_email": "pingou@fedoraproject.org",
                    "emails": [
                        "pingou@fedoraproject.org"
                    ]
                },
                "settings": {
                    "issue_tracker": True,
                    "project_documentation": True,
                    "pull_requests": True,
                },
                "id": 1,
                "description": "test project"
            },
            "commit_stop": "eface8e13bc2a08a3fb22af9a72a8c90e36b8b89",
            "user": {
                "fullname": "Pierre-YvesChibon",
                "name": "pingou",
                "default_email": "pingou@fedoraproject.org",
                "emails": ["pingou@fedoraproject.org"]
            },
            "id": 4,
            "comments": [],
            "branch_from": "master",
            "title": "test request #2",
            "commit_start": "788efeaaf86bde8618f594a8181abb402e1dd904",
            "repo_from": {
                "parent": {
                    "parent": None,
                    "name": "test",
                    "date_created": "1426500194",
                    "tags": [],
                    "user": {
                        "fullname": "Pierre-YvesChibon",
                        "name": "pingou",
                        "default_email": "pingou@fedoraproject.org",
                        "emails": [
                            "pingou@fedoraproject.org"
                        ]
                    },
                    "settings": {
                        "issue_tracker": True,
                        "project_documentation": True,
                        "pull_requests": True,
                    },
                    "id": 1,
                    "description": "test project"
                },
                "settings": {
                    "issue_tracker": True,
                    "project_documentation": True,
                    "pull_requests": True,
                },
                "name": "test",
                "date_created": "1426843440",
                "tags": [],
                "user": {
                    "fullname": "fake user",
                    "name": "fake",
                    "default_email": "fake@fedoraproject.org",
                    "emails": [
                        "fake@fedoraproject.org"
                    ]
                },
                "project_docs": True,
                "id": 6,
                "description": "test project"
            },
            "branch": "master",
            "date_created": "1426843745"
        }

        pagure.lib.git.update_request_from_git(
            self.session,
            reponame='test',
            username=None,
            request_uid='d4182a2ac2d541d884742d3037c26e57',
            json_data=data,
            gitfolder=tests.HERE,
            docfolder=os.path.join(tests.HERE, 'docs'),
            ticketfolder=os.path.join(tests.HERE, 'tickets'),
            requestfolder=os.path.join(tests.HERE, 'requests')
        )
        self.session.commit()

        # After 2 nd insertion
        self.assertEqual(len(repo.requests), 2)
        self.assertEqual(repo.requests[0].id, 7)
        self.assertEqual(
            repo.requests[0].uid, 'd4182a2ac2d541d884742d3037c26e56')
        self.assertEqual(repo.requests[0].title, 'test request')
        self.assertEqual(len(repo.requests[0].comments), 3)
        # 2 entry
        self.assertEqual(repo.requests[1].id, 4)
        self.assertEqual(
            repo.requests[1].uid, 'd4182a2ac2d541d884742d3037c26e57')
        self.assertEqual(repo.requests[1].title, 'test request #2')
        self.assertEqual(len(repo.requests[1].comments), 0)

    def test_read_git_lines(self):
        """ Test the read_git_lines method of pagure.lib.git. """
        self.test_update_git()

        gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        output = pagure.lib.git.read_git_lines(
            ['log', '-1', "--pretty='%s'"], gitrepo)
        self.assertEqual(len(output), 1)
        self.assertTrue(
            output[0].startswith("'Updated issue ")
        )
        self.assertTrue(
            output[0].endswith(": Test issue'")
        )

        # Keeping the new line symbol
        output = pagure.lib.git.read_git_lines(
            ['log', '-1', "--pretty='%s'"], gitrepo, keepends=True)
        self.assertEqual(len(output), 1)
        self.assertTrue(
            output[0].endswith(": Test issue'\n")
        )

    def test_get_revs_between(self):
        """ Test the get_revs_between method of pagure.lib.git. """

        self.test_update_git()

        gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        output = pagure.lib.git.read_git_lines(
            ['log', '-3', "--pretty='%H'"], gitrepo)
        self.assertEqual(len(output), 2)
        from_hash = output[1].replace("'", '')

        # Case 1, repo BASE is null and HEAD is equal to from_hash
        to_hash = '0'
        output1 = pagure.lib.git.get_revs_between(
            to_hash, from_hash, gitrepo, 'refs/heads/master')
        self.assertEqual(output1, [from_hash])

        # Case 2, get revs between two commits (to_hash, from_hash)
        to_hash = output[0].replace("'", '')
        output2 = pagure.lib.git.get_revs_between(
            to_hash, from_hash, gitrepo, 'refs/heads/master')
        self.assertEqual(output2, [to_hash])

        # Case 3, get revs between two commits (from_hash, to_hash)
        output3 = pagure.lib.git.get_revs_between(
            from_hash, to_hash, gitrepo, 'refs/heads/master')
        self.assertEqual(output3, [to_hash])

        # Case 4, get revs between two commits on two different branches
        newgitrepo = tempfile.mkdtemp(prefix='pagure-')
        newrepo = pygit2.clone_repository(gitrepo, newgitrepo)
        newrepo.create_branch('feature', newrepo.head.get_object())

        with open(os.path.join(newgitrepo, 'sources'), 'w') as stream:
            stream.write('foo\n bar')
        newrepo.index.add('sources')
        newrepo.index.write()

        # Commits the files added
        tree = newrepo.index.write_tree()
        author = pygit2.Signature(
            'Alice Author', 'alice@authors.tld')
        committer = pygit2.Signature(
            'Cecil Committer', 'cecil@committers.tld')
        newrepo.create_commit(
            'refs/heads/feature',  # 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
            [to_hash]
        )
        branch_commit = newrepo.revparse_single('refs/heads/feature')

        # Push to origin
        ori_remote = newrepo.remotes[0]
        PagureRepo.push(ori_remote, 'refs/heads/feature')

        # Remove the clone
        shutil.rmtree(newgitrepo)

        output4 = pagure.lib.git.get_revs_between(
            '0', branch_commit.oid.hex, gitrepo, 'refs/heads/feature')
        self.assertEqual(output4, [branch_commit.oid.hex])

    def test_get_author(self):
        """ Test the get_author method of pagure.lib.git. """

        self.test_update_git()

        gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        output = pagure.lib.git.read_git_lines(
            ['log', '-3', "--pretty='%H'"], gitrepo)
        self.assertEqual(len(output), 2)
        for githash in output:
            githash = githash.replace("'", '')
            output = pagure.lib.git.get_author(githash, gitrepo)
            self.assertEqual(output, 'pagure')

    def get_author_email(self):
        """ Test the get_author_email method of pagure.lib.git. """

        self.test_update_git()

        gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        output = pagure.lib.git.read_git_lines(
            ['log', '-3', "--pretty='%H'"], gitrepo)
        self.assertEqual(len(output), 2)
        for githash in output:
            githash = githash.replace("'", '')
            output = pagure.lib.git.get_author_email(githash, gitrepo)
            self.assertEqual(output, 'pagure')

    def test_get_repo_name(self):
        """ Test the get_repo_name method of pagure.lib.git. """
        gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        repo_name = pagure.lib.git.get_repo_name(gitrepo)
        self.assertEqual(repo_name, 'test_ticket_repo')

        repo_name = pagure.lib.git.get_repo_name('foo/bar/baz/test.git')
        self.assertEqual(repo_name, 'test')

        repo_name = pagure.lib.git.get_repo_name('foo.test.git')
        self.assertEqual(repo_name, 'foo.test')

    def test_get_username(self):
        """ Test the get_username method of pagure.lib.git. """
        gitrepo = os.path.join(tests.HERE, 'test_ticket_repo.git')
        repo_name = pagure.lib.git.get_username(gitrepo)
        self.assertEqual(repo_name, None)

        repo_name = pagure.lib.git.get_username('foo/bar/baz/test.git')
        self.assertEqual(repo_name, None)

        repo_name = pagure.lib.git.get_username('foo.test.git')
        self.assertEqual(repo_name, None)

        repo_name = pagure.lib.git.get_username(
            os.path.join(tests.HERE, 'forks', 'pingou', 'foo.test.git'))
        self.assertEqual(repo_name, 'pingou')

if __name__ == '__main__':
    SUITE = unittest.TestLoader().loadTestsFromTestCase(PagureLibGittests)
    unittest.TextTestRunner(verbosity=2).run(SUITE)

repo_name: bill/auger

license: mit


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

"""
 (c) 2016 - Copyright Red Hat Inc

 Authors:
   Clement Verna <cverna@tutanota.com>

"""

import unittest
import sys
import os
import time

import pygit2

sys.path.insert(0, os.path.join(os.path.dirname(
    os.path.abspath(__file__)), '..'))

import pagure.lib.git
import tests

def get_tag_name(tags):
    """ Return a list of the tag names """
    output = []
    for tag in tags:
        output.append(tag['tagname'])
    return output

def add_repo_tag(repo, tags, repo_name):
    """ Use a list to create multiple tags on a git repo """
    for tag in reversed(tags):
        time.sleep(1)
        tests.add_commit_git_repo(
            os.path.join(tests.HERE, 'repos', repo_name),
            ncommits=1)
        first_commit = repo.revparse_single('HEAD')
        tagger = pygit2.Signature('Alice Doe', 'adoe@example.com', 12347, 0)
        repo.create_tag(
            tag, first_commit.oid.hex, pygit2.GIT_OBJ_COMMIT, tagger,
            "Release " + tag)

class PagureLibGitGetTagstests(tests.Modeltests):

    def setUp(self):
        """ Set up the environnment, ran before every tests. """
        super(PagureLibGitGetTagstests, self).setUp()

        pagure.lib.git.SESSION = self.session
        pagure.APP.config['GIT_FOLDER'] = os.path.join(
            tests.HERE, 'repos')
        pagure.APP.config['FORK_FOLDER'] = os.path.join(
            tests.HERE, 'forks')
        pagure.APP.config['TICKETS_FOLDER'] = os.path.join(
            tests.HERE, 'tickets')
        pagure.APP.config['DOCS_FOLDER'] = os.path.join(
            tests.HERE, 'docs')
        pagure.APP.config['REQUESTS_FOLDER'] = os.path.join(
            tests.HERE, 'requests')

    def test_get_git_tags_objects(self):
        """ Test the get_git_tags_objects method of pagure.lib.git. """
        tests.create_projects(self.session)
        tests.create_projects_git(os.path.join(tests.HERE, 'repos'), bare=True)
        project = pagure.lib.get_project(self.session, 'test')

        # Case 1 - Empty repo with no tags
        exp = []
        tags = pagure.lib.git.get_git_tags_objects(project)
        self.assertEqual(exp, get_tag_name(tags))

        tests.add_readme_git_repo(os.path.join(os.path.join(
            tests.HERE, 'repos'), 'test.git'))
        repo = pygit2.Repository(os.path.join(os.path.join(
            tests.HERE, 'repos'), 'test.git'))

        # Case 2 - Repo with one commit and no tags
        exp = []
        tags = pagure.lib.git.get_git_tags_objects(project)
        self.assertEqual(exp, get_tag_name(tags))

        # Case 3 - Simple sort
        exp = ['0.1.0', 'test-0.0.21', '0.0.12-beta', '0.0.12-alpha', '0.0.12',
               '0.0.11', '0.0.3', 'foo-0.0.2', '0.0.1']
        add_repo_tag(repo, exp, 'test.git')
        tags = pagure.lib.git.get_git_tags_objects(project)
        self.assertEqual(exp, get_tag_name(tags))

        # Case 4 - Sorting with different splitting characters
        project = pagure.lib.get_project(self.session, 'test2')
        tests.add_readme_git_repo(os.path.join(os.path.join(
            tests.HERE, 'repos'), 'test2.git'))
        repo = pygit2.Repository(os.path.join(os.path.join(
            tests.HERE, 'repos'), 'test2.git'))

        exp = ['1.0-0_2', '1.0-0_1', '0.1-1_0', '0.1-0_0', '0.0-2_0',
               '0.0-1_34', '0.0-1_11', '0.0-1_3', '0.0-1_2', '0.0-1_1']
        add_repo_tag(repo, exp, 'test2.git')
        tags = pagure.lib.git.get_git_tags_objects(project)
        self.assertEqual(exp, get_tag_name(tags))

if __name__ == '__main__':
    SUITE = unittest.TestLoader().loadTestsFromTestCase(
        PagureLibGitGetTagstests)
    unittest.TextTestRunner(verbosity=2).run(SUITE)


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

"""
 (c) 2015 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>

"""

__requires__ = ['SQLAlchemy >= 0.8']
import pkg_resources

import json
import unittest
import shutil
import sys
import os

import pygit2
from mock import patch

sys.path.insert(0, os.path.join(os.path.dirname(
    os.path.abspath(__file__)), '..'))

import pagure.lib.link
import tests

COMMENTS = [
    'Did you see #1?',
    'This is a duplicate of #2',
    'This is a fixes #3',
    'Might be worth looking at https://fedorahosted.org/pagure/tests2/issue/4',
    'This relates to #5',
    'Could this be related to https://fedorahosted.org/pagure/tests2/issue/6',
]

class PagureLibLinktests(tests.Modeltests):
    """ Tests for pagure.lib.link """

    def test_get_relation_relates(self):
        """ Test the get_relation function of pagure.lib.link with relates.
        """

        self.assertEqual(
            pagure.lib.link.get_relation(
                self.session,
                'test',
                None,
                COMMENTS[0],
                'relates',
            ),
            []
        )

        tests.create_projects(self.session)

        link = pagure.lib.link.get_relation(
            self.session, 'test', None, COMMENTS[4], 'relates')
        self.assertEqual(link, [])

        # Create the issue
        repo = pagure.lib.get_project(self.session, 'test')
        pagure.lib.new_issue(
            self.session,
            repo,
            title='foo',
            content='bar',
            user='pingou',
            ticketfolder=None,
            issue_id=5,
            notify=False)
        self.session.commit()

        for idx, comment in enumerate(COMMENTS):
            link = pagure.lib.link.get_relation(
                self.session, 'test', None, comment, 'relates')
            if idx == 4:
                self.assertEqual(
                    str(link),
                    '[Issue(5, project:test, user:pingou, title:foo)]')
            else:
                self.assertEqual(link, [])

        link = pagure.lib.link.get_relation(
            self.session, 'test', None, COMMENTS[5], 'relates')
        self.assertEqual(link, [])

        # Create the issue
        repo = pagure.lib.get_project(self.session, 'test')
        pagure.lib.new_issue(
            self.session,
            repo,
            title='another foo',
            content='another bar',
            user='pingou',
            ticketfolder=None,
            issue_id=6,
            notify=False)
        self.session.commit()

        for idx, comment in enumerate(COMMENTS):
            link = pagure.lib.link.get_relation(
                self.session, 'test', None, comment, 'relates')
            if idx == 4:
                self.assertEqual(
                    str(link),
                    '[Issue(5, project:test, user:pingou, title:foo)]')
            elif idx == 5:
                self.assertEqual(
                    str(link),
                    '[Issue(6, project:test, user:pingou, title:another foo)]')
            else:
                self.assertEqual(link, [])

    def test_get_relation_fixes(self):
        """ Test the get_relation function of pagure.lib.link with fixes.
        """

        self.assertEqual(
            pagure.lib.link.get_relation(
                self.session,
                'test',
                None,
                COMMENTS[0],
                'fixes',
            ),
            []
        )

        tests.create_projects(self.session)

        link = pagure.lib.link.get_relation(
            self.session, 'test', None, COMMENTS[2], 'fixes')
        self.assertEqual(link, [])

        # Create the issue
        repo = pagure.lib.get_project(self.session, 'test')
        pagure.lib.new_issue(
            self.session,
            repo,
            title='issue 3',
            content='content issue 3',
            user='pingou',
            ticketfolder=None,
            issue_id=3,
            notify=False)
        self.session.commit()

        for idx, comment in enumerate(COMMENTS):
            link = pagure.lib.link.get_relation(
                self.session, 'test', None, comment, 'fixes')
            if idx == 2:
                self.assertEqual(
                    str(link),
                    '[Issue(3, project:test, user:pingou, title:issue 3)]')
            else:
                self.assertEqual(link, [])

    def test_relates_regex(self):
        ''' Test the relates regex present in pagure.lib.link. '''
        text = 'relates  to   http://localhost/fork/pingou/test/issue/1'
        for index, regex in enumerate(pagure.lib.link.RELATES):
            if index == 2:
                self.assertNotEqual(regex.match(text), None)
            else:
                self.assertEqual(regex.match(text), None)

        text = 'relates http://209.132.184.222/fork/pingou/test/issue/1'
        for index, regex in enumerate(pagure.lib.link.RELATES):
            if index == 2:
                self.assertNotEqual(regex.match(text), None)
            else:
                self.assertEqual(regex.match(text), None)

        text = 'This relates  to  #5'
        for index, regex in enumerate(pagure.lib.link.RELATES):
            if index == 0:
                self.assertNotEqual(regex.match(text), None)
            else:
                self.assertEqual(regex.match(text), None)

        text = 'Could this be related to  '\
            ' https://fedorahosted.org/pagure/tests2/issue/6'
        for index, regex in enumerate(pagure.lib.link.RELATES):
            if index == 2:
                self.assertNotEqual(regex.match(text), None)
            else:
                self.assertEqual(regex.match(text), None)

    def test_fixes_regex(self):
        ''' Test the fixes regex present in pagure.lib.link. '''

        # project/issue matches
        def project_match(text, groups):
            match = None
            for regex in pagure.lib.link.FIXES:
                match = regex.match(text)
                if match:
                    break
            self.assertNotEqual(match, None)
            self.assertEqual(len(match.groups()), 2)
            self.assertEqual(match.groups(), groups)

        data = [
            # [string, groups]
        ]

        project_match('fixes     http://localhost/fork/pingou/test/issue/1',
            ('test', '1'))
        project_match('fix http://209.132.184.222/fork/pingou/test/issue/1',
            ('test', '1'))
        project_match('Could this be fixes  '
            ' https://fedorahosted.org/pagure/tests2/issue/6',
            ('tests2', '6'))
        project_match('merged https://pagure.io/myproject/pull-request/70',
            ('myproject', '70'))
        project_match('Now we merge https://pagure.io/myproject/pull-request/99',
            ('myproject', '99'))

        # issue matches
        def issue_match(text, issue):
            match = None
            for regex in pagure.lib.link.FIXES:
                match = regex.match(text)
                if match:
                    break
            self.assertNotEqual(match, None)
            self.assertEqual(len(match.groups()), 1)
            self.assertEqual(match.group(1), issue)

        issue_match('This fixed  #5', '5')
        issue_match('Merged  #17', '17')
        issue_match('Fixed:  #23', '23')
        issue_match('This commit fixes:  #42', '42')
        issue_match('Merge #137', '137')

        # no match
        def no_match(text):
            match = None
            for regex in pagure.lib.link.FIXES:
                match = regex.match(text)
                if match:
                    break
            self.assertEqual(match, None)

        no_match('nowhitespacemerge: #47')
        no_match('This commit unmerges #45')
        no_match('Fixed 45 typos')
        no_match('Fixed 4 typos')
        no_match("Merge branch 'work'")

if __name__ == '__main__':
    SUITE = unittest.TestLoader().loadTestsFromTestCase(PagureLibLinktests)
    unittest.TextTestRunner(verbosity=2).run(SUITE)


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

"""
 (c) 2016 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>
   Farhaan Bukhsh <farhaan.bukhsh@gmail.com>

"""

__requires__ = ['SQLAlchemy >= 0.8']
import pkg_resources

import unittest
import shutil
import sys
import os

from mock import patch

sys.path.insert(0, os.path.join(os.path.dirname(
    os.path.abspath(__file__)), '..'))

import pagure.lib
from pagure.exceptions import PagureException
import pagure.lib.login
import hashlib
from pagure import APP
import tests

class PagureLibLogintests(tests.Modeltests):
    """ Tests for pagure.lib.login """

    def test_id_generator(self):
        ''' Test pagure.lib.login.id_generator. '''
        self.assertEqual(
            pagure.lib.login.id_generator(size=3, chars=['a']),
            'aaa'
        )

    def test_get_users_by_group(self):
        ''' Test pagure.lib.login.get_users_by_group. '''

        users = pagure.lib.login.get_users_by_group(self.session, 'foo')
        self.assertEqual(users, [])

    def test_get_session_by_visitkey(self):
        ''' Test pagure.lib.login.get_session_by_visitkey. '''

        session = pagure.lib.login.get_session_by_visitkey(self.session, 'foo')
        self.assertEqual(session, None)

    def test_generate_hashed_value(self):
        ''' Test pagure.lib.login.generate_hashed_value. '''
        password = pagure.lib.login.generate_hashed_value('foo')
        self.assertTrue(password.startswith('$2$'))
        self.assertEqual(len(password), 63)

    def test_check_password(self):
        ''' Test pagure.lib.login.check_password. '''

        # Version 2
        password = pagure.lib.login.generate_hashed_value('foo')
        self.assertTrue(
            pagure.lib.login.check_password('foo', password))
        self.assertFalse(
            pagure.lib.login.check_password('bar', password))

        # Version 1
        password = '%s%s' % ('foo', APP.config.get('PASSWORD_SEED', None))
        password = '$1$' + hashlib.sha512(password).hexdigest()
        self.assertTrue(pagure.lib.login.check_password('foo', password))
        self.assertFalse(pagure.lib.login.check_password('bar', password))

        # Invalid password  -  No version
        password = '%s%s' % ('foo', APP.config.get('PASSWORD_SEED', None))
        password = hashlib.sha512(password).hexdigest()
        self.assertRaises(
            PagureException,
            pagure.lib.login.check_password,
            'foo', password
        )

        # Invalid password  -  Invalid version
        password = '$3$' + password
        self.assertRaises(
            PagureException,
            pagure.lib.login.check_password,
            'foo',
            password
        )
        password = '%s%s' % ('foo', APP.config.get('PASSWORD_SEED', None))
        password = hashlib.sha512(password).hexdigest()
        self.assertRaises(
            PagureException,
            pagure.lib.login.check_password,
            'foo', password
        )

        # Invalid password  -  Invalid version
        password = '$3$' + password
        self.assertRaises(
            PagureException,
            pagure.lib.login.check_password,
            'foo',
            password
        )

if __name__ == '__main__':
    SUITE = unittest.TestLoader().loadTestsFromTestCase(PagureLibLogintests)
    unittest.TextTestRunner(verbosity=2).run(SUITE)


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

"""
 (c) 2015 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>

"""

__requires__ = ['SQLAlchemy >= 0.8']
import pkg_resources

import unittest
import shutil
import sys
import os

from mock import patch

sys.path.insert(0, os.path.join(os.path.dirname(
    os.path.abspath(__file__)), '..'))

import pagure.lib
import tests

class PagureLibModeltests(tests.Modeltests):
    """ Tests for pagure.lib.model """

    def test_user__repr__(self):
        """ Test the User.__repr__ function of pagure.lib.model. """
        item = pagure.lib.search_user(self.session, email='foo@bar.com')
        self.assertEqual(str(item), 'User: 2 - name foo')
        self.assertEqual('foo', item.user)
        self.assertEqual('foo', item.username)
        self.assertEqual([], item.groups)

    @patch('pagure.lib.git.update_git')
    @patch('pagure.lib.notify.send_email')
    def test_issue__repr__(self, p_send_email, p_ugt):
        """ Test the Issue.__repr__ function of pagure.lib.model. """
        p_send_email.return_value = True
        p_ugt.return_value = True

        tests.create_projects(self.session)
        repo = pagure.lib.get_project(self.session, 'test')

        # Create an issue
        msg = pagure.lib.new_issue(
            session=self.session,
            repo=repo,
            title='Test issue',
            content='We should work on this',
            user='pingou',
            ticketfolder=None
        )
        self.assertEqual(msg.title, 'Test issue')

        issues = pagure.lib.search_issues(self.session, repo)
        self.assertEqual(len(issues), 1)
        self.assertEqual(
            str(issues[0]),
            'Issue(1, project:test, user:pingou, title:Test issue)')

    @patch('pagure.lib.git.update_git')
    @patch('pagure.lib.notify.send_email')
    def test_pullrequest__repr__(self, p_send_email, p_ugt):
        """ Test the PullRequest.__repr__ function of pagure.lib.model. """
        p_send_email.return_value = True
        p_ugt.return_value = True

        tests.create_projects(self.session)
        # Create a forked repo
        item = pagure.lib.model.Project(
            user_id=1,  # pingou
            name='test',
            description='test project #1',
            parent_id=1,
            hook_token='aaabbbyyy',
        )
        self.session.commit()
        self.session.add(item)

        repo = pagure.lib.get_project(self.session, 'test')
        forked_repo = pagure.lib.get_project(
            self.session, 'test', user='pingou')

        # Create an pull-request
        req = pagure.lib.new_pull_request(
            session=self.session,
            repo_from=forked_repo,
            branch_from='master',
            repo_to=repo,
            branch_to='master',
            title='test pull-request',
            user='pingou',
            requestfolder=None,
        )
        self.assertEqual(req.id, 1)
        self.assertEqual(req.title, 'test pull-request')

        self.assertEqual(
            str(req),
            'PullRequest(1, project:test, user:pingou, '
            'title:test pull-request)')

        request = pagure.lib.search_pull_requests(self.session, requestid=1)
        self.assertEqual(
            str(request),
            'PullRequest(1, project:test, user:pingou, '
            'title:test pull-request)')

    def test_paguregroup__repr__(self):
        """ Test the PagureGroup.__repr__ function of pagure.lib.model. """
        item = pagure.lib.model.PagureGroup(
            group_name='admin',
            user_id=1,
        )
        self.session.add(item)
        self.session.commit()

        self.assertEqual(str(item), 'Group: 1 - name admin')

    def test_tagissue__repr__(self):
        """ Test the TagIssue.__repr__ function of pagure.lib.model. """
        self.test_issue__repr__()
        repo = pagure.lib.get_project(self.session, 'test')
        issues = pagure.lib.search_issues(self.session, repo)
        self.assertEqual(len(issues), 1)

        item = pagure.lib.model.Tag(tag='foo')
        self.session.add(item)
        self.session.commit()

        item = pagure.lib.model.TagIssue(
            issue_uid=issues[0].uid,
            tag='foo',
        )
        self.session.add(item)
        self.session.commit()

        self.assertEqual(str(item), 'TagIssue(issue:1, tag:foo)')

if __name__ == '__main__':
    SUITE = unittest.TestLoader().loadTestsFromTestCase(PagureLibModeltests)
    unittest.TextTestRunner(verbosity=2).run(SUITE)


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

"""
 (c) 2016 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>

"""

__requires__ = ['SQLAlchemy >= 0.8']
import pkg_resources

import datetime
import json
import unittest
import shutil
import sys
import tempfile
import os

import pygit2
from mock import patch

sys.path.insert(0, os.path.join(os.path.dirname(
    os.path.abspath(__file__)), '..'))

HERE = os.path.join(os.path.dirname(os.path.abspath(__file__)))
CONFIG = os.path.join(HERE, 'test_config')

os.environ['PAGURE_CONFIG'] = CONFIG

import pagure.lib
import tests
from pagure.lib.repo import PagureRepo

class PagureFlaskRepoOldUrltests(tests.Modeltests):
    """ Tests for flask app controller of pagure """

    def setUp(self):
        """ Set up the environnment, ran before every tests. """
        super(PagureFlaskRepoOldUrltests, self).setUp()

        # We need to reload pagure as otherwise the configuration file will
        # not be taken into account
        pagure.APP.view_functions = {}
        os.environ['PAGURE_CONFIG'] = CONFIG

        reload(pagure)
        reload(pagure.lib)
        reload(pagure.lib.model)
        reload(pagure.ui.admin)
        reload(pagure.ui.app)
        reload(pagure.ui.groups)
        reload(pagure.ui.repo)
        reload(pagure.ui.filters)
        reload(pagure.ui.issues)
        reload(pagure.ui.fork)

        pagure.APP.config['TESTING'] = True
        pagure.SESSION = self.session
        pagure.ui.SESSION = self.session
        pagure.ui.app.SESSION = self.session
        pagure.ui.filters.SESSION = self.session
        pagure.ui.repo.SESSION = self.session

        pagure.APP.config['OLD_VIEW_COMMIT_ENABLED'] = True
        pagure.APP.config['EMAIL_SEND'] = False
        pagure.APP.config['GIT_FOLDER'] = tests.HERE
        pagure.APP.config['FORK_FOLDER'] = os.path.join(
            tests.HERE, 'forks')
        pagure.APP.config['REQUESTS_FOLDER'] = os.path.join(
            tests.HERE, 'requests')
        pagure.APP.config['TICKETS_FOLDER'] = os.path.join(
            tests.HERE, 'tickets')
        pagure.APP.config['DOCS_FOLDER'] = os.path.join(
            tests.HERE, 'docs')
        pagure.APP.config['UPLOAD_FOLDER_PATH'] = os.path.join(
            tests.HERE, 'releases')
        self.app = pagure.APP.test_client()

    def tearDown(self):
        """ Tear down the environnment, after every tests. """
        super(PagureFlaskRepoOldUrltests, self).tearDown()
        if 'PAGURE_CONFIG' in os.environ:
            del os.environ['PAGURE_CONFIG']

        # We need to reload pagure as otherwise the configuration file will
        # remain set for the other tests
        pagure.APP.view_functions = {}

        reload(pagure)
        reload(pagure.lib)
        reload(pagure.lib.model)
        reload(pagure.hooks)
        reload(pagure.hooks.mail)
        reload(pagure.hooks.irc)
        reload(pagure.hooks.fedmsg)
        reload(pagure.hooks.pagure_force_commit)
        reload(pagure.hooks.pagure_hook)
        reload(pagure.hooks.pagure_request_hook)
        reload(pagure.hooks.pagure_ticket_hook)
        reload(pagure.hooks.rtd)
        reload(pagure.ui.admin)
        reload(pagure.ui.app)
        reload(pagure.ui.groups)
        reload(pagure.ui.repo)
        reload(pagure.ui.filters)
        reload(pagure.ui.plugins)
        reload(pagure.ui.issues)
        reload(pagure.ui.fork)

        pagure.APP.config['EMAIL_SEND'] = False
        pagure.LOG.handlers = []

    def test_view_commit_old(self):
        """ Test the view_commit_old endpoint. """

        tests.create_projects(self.session)
        tests.create_projects_git(tests.HERE, bare=True)

        # Add a README to the git repo - First commit
        tests.add_readme_git_repo(os.path.join(tests.HERE, 'test.git'))
        repo = pygit2.Repository(os.path.join(tests.HERE, 'test.git'))
        commit = repo.revparse_single('HEAD')

        # View first commit
        output = self.app.get('/test/%s' % commit.oid.hex)
        self.assertEqual(output.status_code, 302)

        output = self.app.get(
            '/test/%s' % commit.oid.hex, follow_redirects=True)
        self.assertEqual(output.status_code, 200)
        self.assertTrue(
            '
'
            in output.data)
        self.assertTrue(' Authored by Alice Author' in output.data)
        self.assertTrue('Committed by Cecil Committer' in output.data)
        self.assertTrue(
            '+ Pagure' in output.data)
        self.assertTrue(
            '+ ======' in output.data)

        self.app = pagure.APP.test_client()
        # View first commit - with the old URL scheme
        output = self.app.get(
            '/test/%s' % commit.oid.hex, follow_redirects=True)
        self.assertEqual(output.status_code, 200)
        self.assertTrue(
            '
'
            in output.data)
        self.assertTrue(' Authored by Alice Author' in output.data)
        self.assertTrue('Committed by Cecil Committer' in output.data)
        self.assertTrue(
            '+ Pagure' in output.data)
        self.assertTrue(
            '+ ======' in output.data)

        # Add some content to the git repo
        tests.add_content_git_repo(os.path.join(tests.HERE, 'test.git'))

        repo = pygit2.Repository(os.path.join(tests.HERE, 'test.git'))
        commit = repo.revparse_single('HEAD')

        # View another commit
        output = self.app.get(
            '/test/%s' % commit.oid.hex, follow_redirects=True)
        self.assertEqual(output.status_code, 200)
        self.assertTrue(
            '
'
            in output.data)
        self.assertTrue(' Authored by Alice Author' in output.data)
        self.assertTrue('Committed by Cecil Committer' in output.data)
        self.assertTrue(
            # new version of pygments
            '
'
            '
'
            ''
            ''
            '@@ -0,0 +1,3 @@' in output.data
            or
            # old version of pygments
            '
'
            '
'
            ''
            '@@ -0,0 +1,3 @@' in output.data)

        # Add a fork of a fork
        item = pagure.lib.model.Project(
            user_id=1,  # pingou
            name='test3',
            description='test project #3',
            parent_id=1,
            hook_token='aaabbbkkk',
        )
        self.session.add(item)
        self.session.commit()
        forkedgit = os.path.join(
            tests.HERE, 'forks', 'pingou', 'test3.git')

        tests.add_content_git_repo(forkedgit)
        tests.add_readme_git_repo(forkedgit)

        repo = pygit2.Repository(forkedgit)
        commit = repo.revparse_single('HEAD')

        # Commit does not exist in anothe repo :)
        output = self.app.get(
            '/test/%s' % commit.oid.hex, follow_redirects=True)
        self.assertEqual(output.status_code, 404)

        # View commit of fork
        output = self.app.get(
            '/fork/pingou/test3/%s' % commit.oid.hex, follow_redirects=True)
        self.assertEqual(output.status_code, 200)
        self.assertTrue(
            '
'
            in output.data)
        self.assertTrue(' Authored by Alice Author' in output.data)
        self.assertTrue('Committed by Cecil Committer' in output.data)
        self.assertTrue(
            '+ Pagure' in output.data)
        self.assertTrue(
            '+ ======' in output.data)

        # View commit of fork - With the old URL scheme
        output = self.app.get(
            '/fork/pingou/test3/%s' % commit.oid.hex, follow_redirects=True)
        self.assertEqual(output.status_code, 200)
        self.assertTrue(
            '
'
            in output.data)
        self.assertTrue(' Authored by Alice Author' in output.data)
        self.assertTrue('Committed by Cecil Committer' in output.data)
        self.assertTrue(
            '+ Pagure' in output.data)
        self.assertTrue(
            '+ ======' in output.data)

        # Try the old URL scheme with a short hash
        output = self.app.get(
            '/fork/pingou/test3/%s' % commit.oid.hex[:10],
            follow_redirects=True)
        self.assertEqual(output.status_code, 404)
        self.assertIn('
Project not found
', output.data)

if __name__ == '__main__':
    SUITE = unittest.TestLoader().loadTestsFromTestCase(PagureFlaskRepoOldUrltests)
    unittest.TextTestRunner(verbosity=2).run(SUITE)


code:
mock==1.1.2
nose
nosexcover

# Seems that mock doesn't list this one
funcsigs


code:
#!/usr/bin/env python

"""
 (c) 2015 - Copyright Red Hat Inc

 Authors:
   Pierre-Yves Chibon <pingou@pingoured.fr>

This server listens to message sent via redis and send the corresponding
web-hook request.

Using this mechanism, we no longer block the main application if the
receiving end is offline or so.

"""

import datetime
import hashlib
import hmac
import json
import logging
import os
import requests
import time
import uuid

import six
import trollius
import trollius_redis

from kitchen.text.converters import to_bytes

log = logging.getLogger(__name__)

if 'PAGURE_CONFIG' not in os.environ \
        and os.path.exists('/etc/pagure/pagure.cfg'):
    print 'Using configuration file `/etc/pagure/pagure.cfg`'
    os.environ['PAGURE_CONFIG'] = '/etc/pagure/pagure.cfg'

import pagure
import pagure.lib
from pagure.exceptions import PagureEvException

_i = 0

def call_web_hooks(project, topic, msg):
    ''' Sends the web-hook notification. '''
    log.info(
        "Processing project: %s - topic: %s", project.fullname, topic)
    log.debug('msg: %s', msg)

    # Send web-hooks notification
    global _i
    _i += 1
    year = datetime.datetime.now().year
    if isinstance(topic, six.text_type):
        topic = to_bytes(topic, encoding='utf8', nonstring="passthru")
    msg = dict(
        topic=topic.decode('utf-8'),
        msg=msg,
        timestamp=int(time.time()),
        msg_id=str(year) + '-' + str(uuid.uuid4()),
        i=_i,
    )

    content = json.dumps(msg)
    hashhex = hmac.new(
        str(project.hook_token), content, hashlib.sha1).hexdigest()
    headers = {
        'X-Pagure-Topic': topic,
        'X-Pagure-Signature': hashhex
    }
    msg = json.dumps(msg)
    for url in project.settings.get('Web-hooks').split('\n'):
        url = url.strip()
        log.info('Calling url %s' % url)
        try:
            req = requests.post(
                url,
                headers=headers,
                data={'payload': msg}
            )
            if not req:
                log.info(
                    'An error occured while querying: %s - '
                    'Error code: %s' % (url, req.status_code))
        except (requests.exceptions.RequestException, Exception) as err:
            log.info(
                'An error occured while querying: %s - Error: %s' % (
                    url, err))

@trollius.coroutine
def handle_messages():
        connection = yield trollius.From(trollius_redis.Connection.create(
            host='0.0.0.0', port=6379, db=0))

        # Create subscriber.
        subscriber = yield trollius.From(connection.start_subscribe())

        # Subscribe to channel.
        yield trollius.From(subscriber.subscribe(['pagure.hook']))

        # Inside a while loop, wait for incoming events.
        while True:
            reply = yield trollius.From(subscriber.next_published())
            log.info(
                'Received: %s on channel: %s',
                repr(reply.value), reply.channel)
            data = json.loads(reply.value)
            username = None
            if data['project'].startswith('forks'):
                _, username, projectname = data['project'].split('/', 2)
            else:
                projectname = data['project']

            project = pagure.lib.get_project(
                session=pagure.SESSION, name=projectname, user=username)
            log.info('Got the project, going to the webhooks')
            call_web_hooks(project, data['topic'], data['msg'])

def main():
    server = None
    try:
        loop = trollius.get_event_loop()
        tasks = [
            trollius.async(handle_messages()),
        ]
        loop.run_until_complete(trollius.wait(tasks))
        loop.run_forever()
    except KeyboardInterrupt:
        pass
    except trollius.ConnectionResetError:
        pass

    log.info("End Connection")
    loop.close()
    log.info("End")

if __name__ == '__main__':
    log = logging.getLogger("")
    formatter = logging.Formatter(
        "%(asctime)s %(levelname)s [%(module)s:%(lineno)d] %(message)s")

    # setup console logging
    log.setLevel(logging.DEBUG)
    ch = logging.StreamHandler()
    ch.setLevel(logging.DEBUG)

    aslog = logging.getLogger("asyncio")
    aslog.setLevel(logging.DEBUG)

    ch.setFormatter(formatter)
    log.addHandler(ch)
    main()


code:
[Unit]
Description=Pagure WebHook server (Allowing web-hook notifications)
After=redis.target
Documentation=https://pagure.io/pagure

[Service]
ExecStart=/usr/libexec/pagure-webhook/pagure-webhook-server.py
Type=simple
User=git
Group=git
Restart=on-failure

[Install]
WantedBy=multi-user.target


code:
"""Copyright (c) 2010, Helsinki Institute of Information Technology HIIT
Matti Nelimarkka <matti.nelimarkka@hiit.fi>

All rights reserved.

Redistribution and use in source and binary forms,
with or without modification, are permitted provided that
the following conditions are met:

Redistributions of source code must retain the above copyright notice,
this list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.

Neither the name of the Helsinki Institute of Information Technology HIIT
nor the names of  its contributors may be used to endorse or promote products derived
from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
AS IS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
"""

import inbox,  appuifw, e32
import socket, urllib

URL = "http://labs.humanisti.fixme.fi/sizzle/ossi/jsclient/v1_tester/alllog.php?"

def message_received( id ):
    box = inbox.Inbox()
    try:
        sms_text = box.content( id )
        sms_text = urllib.quote( sms_text.encode('utf8') )
        sms_number = box.address( id )
        data = {"sms" : sms_text, "number" : sms_number}
        data = urllib.urlencode( data )
        urllib.urlopen(URL + data)
        global count
        count = count + 1
        print "Message " + str( count )
    except SymbianError:
        print 'Symbian failure'
        message_received( id )

def init_handler():
    box = inbox.Inbox()
    box.bind( message_received )
    app_lock.wait()

## Setup
## TODO: ugly >.<
aps = [ap['name'] for ap in socket.access_points()]
aps.sort()
apid = appuifw.popup_menu(aps,u'Select gateway')
socket.set_default_access_point(aps[apid])

## Init
app_lock = e32.Ao_lock()
count = 0
print "Initializing gateway"
init_handler()
print "Gateway closed"

repo_name: snapshot/msggw

license: unknown