~maxb/bzr-svn/fetch-svn-rev-info-progress-bar

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

 

# Copyright (C) 2005-2009 Jelmer Vernooij <jelmer@samba.org>

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

from bzrlib.plugins.svn.mapping import (

    estimate_bzr_ancestors,

    escape_svn_path,

    get_roundtrip_ancestor_revids,

    is_bzr_revision_fileprops,

    is_bzr_revision_revprops,

    mapping_registry,

    parse_merge_property,

    parse_revid_property,

    unescape_svn_path,

    )

 

 

class MetadataMarshallerTests(TestCase):

    def test_generate_revision_metadata_none(self):

                generate_revision_metadata(None, None, None, None))

 

    def test_generate_revision_metadata_committer(self):

                generate_revision_metadata(None, None, "bla", None))

 

    def test_generate_revision_metadata_timestamp(self):

                    None, None))

    def test_generate_revision_metadata_properties(self):

                "\tpropbla: bloe\n" +

                "\tpropfoo: bla\n",

                generate_revision_metadata(None, None,

                    None, {"propbla": "bloe", "propfoo": "bla"}))

 

    def test_generate_revision_metadata_properties_newline(self):

                "\tpropbla: bloe\n" +

                "\tpropbla: bla\n",

                generate_revision_metadata(None, None,

 

    def test_parse_revision_metadata_properties(self):

        rev = Revision('someid')

                                "\tha: ha\n", rev)

        self.assertEquals({"foo": "bar", "ha": "ha"}, rev.properties)

 

    def test_parse_revision_metadata_properties_newline(self):

        rev = Revision('someid')

                                "\tfoo: bar2\n" +

                                "\tha: ha\n", rev)

        self.assertEquals({"foo": "bar\nbar2", "ha": "ha"}, rev.properties)

 

    def test_parse_revision_metadata_no_colon(self):

        rev = Revision('someid')

                lambda: parse_revision_metadata("bla", rev))

 

    def test_parse_revision_metadata_specialchar(self):

 

    def test_parse_revision_metadata_invalid_name(self):

        rev = Revision('someid')

                lambda: parse_revision_metadata("bla: b", rev))

 

    def test_parse_revid_property(self):

        self.assertEquals((42, "bloe bla"), parse_revid_property("42 bloe bla"))

 

    def test_parse_revid_property_invalid(self):

                lambda: parse_revid_property("blabla"))

 

    def test_parse_revid_property_empty_revid(self):

                lambda: parse_revid_property("2 "))

 

    def test_parse_revid_property_newline(self):

                lambda: parse_revid_property("foo\nbar"))

 

 

class ParseRevisionIdTests(TestCase):

 

    def test_v4(self):

                mapping_registry.parse_revision_id("svn-v4:uuid:trunk:1"))

 

    def test_v3(self):

                mapping_registry.parse_revision_id("svn-v3-trunk0:uuid:trunk:1"))

 

    def test_v3_undefined(self):

                mapping_registry.parse_revision_id("svn-v3-undefined:uuid:trunk:1"))

 

    def test_v2(self):

                         mapping_registry.parse_revision_id("svn-v2:1@uuid-trunk"))

 

    def test_v1(self):

                         mapping_registry.parse_revision_id("svn-v1:1@uuid-trunk"))

 

    def test_except(self):

                         mapping_registry.parse_revision_id, "svn-v0:1@uuid-trunk")

 

    def test_except_nonsvn(self):

                         mapping_registry.parse_revision_id, "blah")

 

 

class EscapeTest(TestCase):

        self.assertEqual("", escape_svn_path(""))

 

    def test_escape_svn_path_simple(self):

        self.assertEquals(2, estimate_bzr_ancestors({"bzr:revision-id:v42": "bla\nblie\n"}))

 

    def test_multiple(self):

            "bzr:revision-id:v50": "blie\nblie\n"}))

 

 

 

 

class RoundTripAncestorRevids(TestCase):

    def test_none(self):

        self.assertEquals([], list(get_roundtrip_ancestor_revids({})))

 

    def test_simple(self):

                list(get_roundtrip_ancestor_revids({mapping.SVN_PROP_BZR_REVISION_ID+"v42-scheme": "42 arevid\n"})))

 

    def test_multiple(self):

                set(get_roundtrip_ancestor_revids({

                    mapping.SVN_PROP_BZR_REVISION_ID+"v42-scheme": "42 arevid\n",

                    mapping.SVN_PROP_BZR_REVISION_ID+"v90-ll": "50 brevid\n",

 

    def test_import_revision_svnprops(self):

        rev = Revision(None)

        self.assertEquals("Somebody", rev.committer)

        self.assertEquals("A log msg", rev.message)

        self.assertEquals({}, rev.properties)

        self.assertEquals(0.0, rev.timezone)