view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/python/tests/ra.py  view on Meta::CPAN

    class ChangeReceiver(delta.Editor):
        def __init__(self):
            self.textdeltas = []

        def apply_textdelta(self, file_baton, base_checksum, pool=None):
            def textdelta_handler(textdelta):
                if textdelta is not None:
                    self.textdeltas.append(textdelta)
            return textdelta_handler

    editor = ChangeReceiver()

    e_ptr, e_baton = delta.make_editor(editor)

    fs_revnum = fs.youngest_rev(self.fs)

    sess_url = ra.get_session_url(self.ra_ctx)
    try:
        ra.reparent(self.ra_ctx, self.repos_uri+"/trunk")
        reporter, reporter_baton = ra.do_diff2(self.ra_ctx, fs_revnum,
                                               "README.txt", 0, 0, 1,
                                               self.repos_uri
                                                 +"/trunk/README.txt",
                                               e_ptr, e_baton)
        reporter.set_path(reporter_baton, "", 0, True, None)
        reporter.finish_report(reporter_baton)
    finally:
        ra.reparent(self.ra_ctx, sess_url)

    self.assertEqual("A test.\n", editor.textdeltas[0].new_data)
    self.assertEqual(1, len(editor.textdeltas))

  def test_get_locations(self):
    locations = ra.get_locations(self.ra_ctx, "trunk/README.txt", 2, list(range(1, 5)))
    self.assertEqual(locations, {
        2: '/trunk/README.txt',
        3: '/trunk/README.txt',
        4: '/trunk/README.txt'})

  def test_has_capability(self):
      self.assertEqual(True, ra.has_capability(self.ra_ctx,
                                               ra.SVN_RA_CAPABILITY_DEPTH))

  def test_get_file_revs(self):
    def rev_handler(path, rev, rev_props, prop_diffs, pool):
        self.assert_(rev == 2 or rev == 3)
        self.assertEqual(path, "/trunk/README.txt")
        if rev == 2:
            self.assertEqual(rev_props, {
              'svn:log': 'Added README.',
              'svn:author': 'john',
              'svn:date': '2005-04-01T13:12:18.216267Z'
            })
            self.assertEqual(prop_diffs, {})
        elif rev == 3:
            self.assertEqual(rev_props, {
              'svn:log': 'Fixed README.\n',
              'svn:author': 'kate',
              'svn:date': '2005-04-01T13:24:58.234643Z'
            })
            self.assertEqual(prop_diffs, {'svn:mime-type': 'text/plain', 'svn:eol-style': 'native'})

    ra.get_file_revs(self.ra_ctx, "trunk/README.txt", 0, 10, rev_handler)

  def test_lock(self):
    def callback(baton, path, do_lock, lock, ra_err, pool):
      pass
    # This test merely makes sure that the arguments can be wrapped
    # properly. svn.ra.lock() currently fails because it is not possible
    # to retrieve the username from the auth_baton yet.
    self.assertRaises(core.SubversionException,
      lambda: ra.lock(self.ra_ctx, {"": 0}, "sleutel", False, callback))

  def test_get_log2(self):
    # Get an interesting commmit.
    self.test_commit3()
    rev = fs.youngest_rev(self.fs)
    revprops = ra.rev_proplist(self.ra_ctx, rev)
    self.assert_("svn:log" in revprops)
    self.assert_("testprop" in revprops)

    def receiver(log_entry, pool):
      called[0] = True
      self.assertEqual(log_entry.revision, rev)
      if discover_changed_paths:
        self.assertEqual(list(log_entry.changed_paths.keys()), ['/bla3'])
        changed_path = log_entry.changed_paths['/bla3']
        self.assert_(changed_path.action in ['A', 'D', 'R', 'M'])
        self.assertEqual(changed_path.copyfrom_path, None)
        self.assertEqual(changed_path.copyfrom_rev, -1)
      else:
        self.assertEqual(log_entry.changed_paths, None)
      if log_revprops is None:
        self.assertEqual(log_entry.revprops, revprops)
      elif len(log_revprops) == 0:
        self.assert_(log_entry.revprops == None or len(log_entry.revprops) == 0)
      else:
        revprop_names = sorted(log_entry.revprops.keys())
        log_revprops.sort()
        self.assertEqual(revprop_names, log_revprops)
        for i in log_revprops:
          self.assertEqual(log_entry.revprops[i], revprops[i],
                           msg="%s != %s on %s"
                               % (log_entry.revprops[i], revprops[i],
                                  (log_revprops, discover_changed_paths)))

    for log_revprops in (
      # Retrieve the standard three.
      ["svn:author", "svn:date", "svn:log"],
      # Retrieve just testprop.
      ["testprop"],
      # Retrieve all.
      None,
      # Retrieve none.
      [],
      ):
      for discover_changed_paths in [True, False]:
        called = [False]
        ra.get_log2(self.ra_ctx, [""],
                    rev, rev,   # start, end
                    1,          # limit