import datetime
import unittest
from mock import patch, Mock, MagicMock, call
from nose.tools import assert_equal

from pylons import tmpl_context as c

from allura import model as M
from allura.controllers.repository import topo_sort
from alluratest.controller import setup_unit_test

class TestCommitRunBuilder(unittest.TestCase):

    def setUp(self):
        setup_unit_test()
        commits = [
            M.repo.CommitDoc.make(dict(
                _id=str(i)))
            for i in range(10) ]
        for p,c in zip(commits, commits[1:]):
            p.child_ids = [ c._id ]
            c.parent_ids = [ p._id ]
        for ci in commits:
            ci.m.save()
        self.commits = commits

    def test_single_pass(self):
        crb = M.repo_refresh.CommitRunBuilder(
            [ci._id for ci in self.commits])
        crb.run()
        self.assertEqual(M.repo.CommitRunDoc.m.count(), 1)

    def test_two_pass(self):
        crb = M.repo_refresh.CommitRunBuilder(
            [ci._id for ci in self.commits[:5]])
        crb.run()
        crb = M.repo_refresh.CommitRunBuilder(
            [ci._id for ci in self.commits[5:]])
        crb.run()
        self.assertEqual(M.repo.CommitRunDoc.m.count(), 2)
        crb.cleanup()
        self.assertEqual(M.repo.CommitRunDoc.m.count(), 1)

    def test_svn_like(self):
        for ci in self.commits:
            crb = M.repo_refresh.CommitRunBuilder([ci._id])
            crb.run()
            crb.cleanup()
        self.assertEqual(M.repo.CommitRunDoc.m.count(), 1)

    def test_reversed(self):
        for ci in reversed(self.commits):
            crb = M.repo_refresh.CommitRunBuilder([ci._id])
            crb.run()
            crb.cleanup()
        self.assertEqual(M.repo.CommitRunDoc.m.count(), 1)

class TestTopoSort(unittest.TestCase):
    def test_commit_dates_out_of_order(self):
        """Commits should be sorted by their parent/child relationships,
        regardless of the date on the commit.
        """
        head_ids = ['dev', 'master']
        parents = {
            'dev':        ['dev@{1}'],
            'dev@{1}':    ['master'],
            'master':     ['master@{1}'],
            'master@{1}': ['master@{2}'],
            'master@{2}': ['master@{3}'],
            'master@{3}': []}
        children = {
            'master@{3}': ['master@{2}'],
            'master@{2}': ['master@{1}'],
            'master@{1}': ['master'],
            'master':     ['dev@{1}'],
            'dev@{1}':    ['dev'],
            'dev':        []}
        dates = {
            'dev@{1}':    datetime.datetime(2012, 1, 1),
            'master@{3}': datetime.datetime(2012, 2, 1),
            'master@{2}': datetime.datetime(2012, 3, 1),
            'master@{1}': datetime.datetime(2012, 4, 1),
            'master':     datetime.datetime(2012, 5, 1),
            'dev':        datetime.datetime(2012, 6, 1)}
        result = topo_sort(children, parents, dates, head_ids)
        self.assertEqual(list(result), ['dev', 'dev@{1}', 'master',
            'master@{1}', 'master@{2}', 'master@{3}'])


def tree(name, id, trees=None, blobs=None):
    t = Mock(tree_ids=[], blob_ids=[], other_ids=[])
    t.name = name
    t.id = id
    t._id = id
    if trees is not None:
        t.tree_ids = trees
    if blobs is not None:
        t.blob_ids = blobs
    return t


def blob(name, id):
    b = Mock()
    b.name = name
    b.id = id
    return b


class TestTree(unittest.TestCase):

    @patch('allura.model.repo.Tree.__getitem__')
    def test_get_obj_by_path(self, getitem):
        tree = M.repo.Tree()
        # test with relative path
        tree.get_obj_by_path('some/path/file.txt')
        getitem.assert_called_with('some')
        getitem().__getitem__.assert_called_with('path')
        getitem().__getitem__().__getitem__.assert_called_with('file.txt')
        # test with absolute path
        tree.get_obj_by_path('/some/path/file.txt')
        getitem.assert_called_with('some')
        getitem().__getitem__.assert_called_with('path')
        getitem().__getitem__().__getitem__.assert_called_with('file.txt')


class TestBlob(unittest.TestCase):
    def test_context_no_create(self):
        blob = M.repo.Blob(Mock(), Mock(), Mock())
        blob.path = Mock(return_value='path')
        blob.prev_commit = Mock()
        blob.next_commit = Mock()
        blob.prev_commit.get_path.return_value = '_prev'
        blob.next_commit.get_path.return_value = '_next'
        context = blob.context()
        assert_equal(context, {'prev': '_prev', 'next': '_next'})
        blob.prev_commit.get_path.assert_called_with('path', create=False)
        blob.next_commit.get_path.assert_called_with('path', create=False)

        blob.prev_commit.get_path.side_effect = KeyError
        blob.next_commit.get_path.side_effect = KeyError
        context = blob.context()
        assert_equal(context, {'prev': None, 'next': None})

    @patch.object(M.repo.LastCommit, '_prev_commit_id')
    def test_prev_commit_no_create(self, lc_pcid):
        lc_pcid.return_value = None
        blob = M.repo.Blob(Mock(), 'foo', 'bid')
        blob.tree.path.return_value = '/path/'
        pc = blob.prev_commit
        lc_pcid.assert_called_once_with(blob.commit, 'path/foo')
        assert not blob.repo.commit.called
        assert_equal(pc, None)

        lc_pcid.reset_mock()
        lc_pcid.return_value = 'pcid'
        blob = M.repo.Blob(Mock(), 'foo', 'bid')
        blob.tree.path.return_value = '/path/'
        blob.repo.commit.return_value = 'commit'
        pc = blob.prev_commit
        lc_pcid.assert_called_once_with(blob.commit, 'path/foo')
        blob.repo.commit.assert_called_once_with('pcid')
        assert_equal(pc, 'commit')

    def test_next_commit_no_create(self):
        blob = M.repo.Blob(MagicMock(), MagicMock(), MagicMock())
        blob._id = 'blob1'
        blob.path = Mock(return_value='path')
        blob.commit.context().__getitem__.return_value = None
        nc = blob.next_commit
        assert_equal(nc, None)

        _next = MagicMock()
        _next.context().__getitem__.return_value = None
        _next.get_path.return_value = Mock(_id='blob2')
        blob = M.repo.Blob(MagicMock(), MagicMock(), MagicMock())
        blob._id = 'blob1'
        blob.path = Mock(return_value='path')
        blob.commit.context().__getitem__.return_value = [_next]
        nc = blob.next_commit
        _next.get_path.assert_called_with('path', create=False)
        assert_equal(nc, _next)


class TestCommit(unittest.TestCase):
    def test_get_path_no_create(self):
        commit = M.repo.Commit()
        commit.get_tree = MagicMock()
        commit.get_path('foo/', create=False)
        commit.get_tree.assert_called_with(False)
        commit.get_tree().__getitem__.assert_called_with('foo')
        commit.get_tree().__getitem__.assert_not_called_with('')

    def test_get_tree_no_create(self):
        c.model_cache = Mock()
        c.model_cache.get.return_value = None
        commit = M.repo.Commit()
        commit.repo = Mock()

        commit.tree_id = None
        tree = commit.get_tree(create=False)
        assert not commit.repo.compute_tree_new.called
        assert not c.model_cache.get.called
        assert_equal(tree, None)

        commit.tree_id = 'tree'
        tree = commit.get_tree(create=False)
        assert not commit.repo.compute_tree_new.called
        c.model_cache.get.assert_called_with(M.repo.Tree, dict(_id='tree'))
        assert_equal(tree, None)

        _tree = Mock()
        c.model_cache.get.return_value = _tree
        tree = commit.get_tree(create=False)
        _tree.set_context.assert_called_with(commit)
        assert_equal(tree, _tree)

    @patch.object(M.repo.Tree.query, 'get')
    def test_get_tree_create(self, tree_get):
        c.model_cache = Mock()
        c.model_cache.get.return_value = None
        commit = M.repo.Commit()
        commit.repo = Mock()

        commit.repo.compute_tree_new.return_value = None
        commit.tree_id = None
        tree = commit.get_tree()
        commit.repo.compute_tree_new.assert_called_once_with(commit)
        assert not c.model_cache.get.called
        assert not tree_get.called
        assert_equal(tree, None)

        commit.repo.compute_tree_new.reset_mock()
        commit.repo.compute_tree_new.return_value = 'tree'
        _tree = Mock()
        c.model_cache.get.return_value = _tree
        tree = commit.get_tree()
        commit.repo.compute_tree_new.assert_called_once_with(commit)
        assert not tree_get.called
        c.model_cache.get.assert_called_once_with(M.repo.Tree, dict(_id='tree'))
        _tree.set_context.assert_called_once_with(commit)
        assert_equal(tree, _tree)

        commit.repo.compute_tree_new.reset_mock()
        c.model_cache.get.reset_mock()
        commit.tree_id = 'tree2'
        tree = commit.get_tree()
        assert not commit.repo.compute_tree_new.called
        assert not tree_get.called
        c.model_cache.get.assert_called_once_with(M.repo.Tree, dict(_id='tree2'))
        _tree.set_context.assert_called_once_with(commit)
        assert_equal(tree, _tree)

        commit.repo.compute_tree_new.reset_mock()
        c.model_cache.get.reset_mock()
        c.model_cache.get.return_value = None
        tree_get.return_value = _tree
        tree = commit.get_tree()
        c.model_cache.get.assert_called_once_with(M.repo.Tree, dict(_id='tree2'))
        commit.repo.compute_tree_new.assert_called_once_with(commit)
        assert_equal(commit.tree_id, 'tree')
        tree_get.assert_called_once_with(_id='tree')
        c.model_cache.set.assert_called_once_with(M.repo.Tree, dict(_id='tree'), _tree)
        _tree.set_context.assert_called_once_with(commit)
        assert_equal(tree, _tree)

    def test_tree_create(self):
        commit = M.repo.Commit()
        commit.get_tree = Mock()
        tree = commit.tree
        commit.get_tree.assert_called_with(create=True)