Exemplo n.º 1
0
 def svn_delete(self, rpath, even_if_modified=False):
   "Delete a WC path locally."
   lpath = local_path(rpath)
   args = []
   if even_if_modified:
     args += ['--force']
   actions.run_and_verify_svn(None, None, [], 'delete', lpath, *args)
Exemplo n.º 2
0
def fail_add_mixed_eol_style(sbox):
    "fail to add a file with mixed EOL style"

    from svntest.actions import run_and_verify_svn, run_and_verify_unquiet_status

    # Bootstrap
    sbox.build()

    filename = 'mixed-eol.txt'
    filepath = os.path.join(sbox.wc_dir, filename)
    parameters = [
        '--auto-props', '--config-option=config:auto-props:' + filename +
        '=svn:eol-style=native'
    ]

    svntest.main.file_write(filepath, 'foo\nbar\r\nbaz\r')

    expected_stderr = "svn: E200009: File '.*" + filename + \
                      "' has inconsistent newlines" + \
                      "|" + "svn: E135000: Inconsistent line ending style\n"
    run_and_verify_svn(None, [], expected_stderr, 'add', filepath, *parameters)

    expected_status = svntest.wc.State(sbox.wc_dir,
                                       {filename: Item(status='? ')})
    run_and_verify_unquiet_status(filepath, expected_status)
Exemplo n.º 3
0
def fail_add_mixed_eol_style(sbox):
    "fail to add a file with mixed EOL style"

    from svntest.actions import run_and_verify_svn, run_and_verify_unquiet_status

    # Bootstrap
    sbox.build()

    filename = "mixed-eol.txt"
    filepath = os.path.join(sbox.wc_dir, filename)
    parameters = ["--auto-props", "--config-option=config:auto-props:" + filename + "=svn:eol-style=native"]

    svntest.main.file_write(filepath, "foo\nbar\r\nbaz\r")

    expected_stderr = (
        "svn: E200009: File '.*"
        + filename
        + "' has inconsistent newlines"
        + "|"
        + "svn: E135000: Inconsistent line ending style\n"
    )
    run_and_verify_svn(None, [], expected_stderr, "add", filepath, *parameters)

    expected_status = svntest.wc.State(sbox.wc_dir, {filename: Item(status="? ")})
    run_and_verify_unquiet_status(filepath, expected_status)
Exemplo n.º 4
0
 def svn_delete(self, rpath, even_if_modified=False):
     "Delete a WC path locally."
     lpath = local_path(rpath)
     args = []
     if even_if_modified:
         args += ['--force']
     actions.run_and_verify_svn(None, [], 'delete', lpath, *args)
Exemplo n.º 5
0
def fail_add_mixed_eol_style(sbox):
  "fail to add a file with mixed EOL style"

  from svntest.actions import run_and_verify_svn, run_and_verify_unquiet_status

  # Bootstrap
  sbox.build()

  filename = 'mixed-eol.txt'
  filepath = os.path.join(sbox.wc_dir, filename)
  parameters = ['--auto-props',
                '--config-option=config:auto-props:' + filename
                + '=svn:eol-style=native']

  svntest.main.file_write(filepath, 'foo\nbar\r\nbaz\r')

  expected_stderr = "svn: E200009: File '.*" + filename + \
                    "' has inconsistent newlines" + \
                    "|" + "svn: E135000: Inconsistent line ending style\n"
  run_and_verify_svn([], expected_stderr,
                     'add', filepath, *parameters)

  expected_status = svntest.wc.State(sbox.wc_dir,
    {filename : Item(status='? ')})
  run_and_verify_unquiet_status(filepath, expected_status)
Exemplo n.º 6
0
  def svn_mkdir(self, rpath):
    lpath = local_path(rpath)
    actions.run_and_verify_svn(None, None, [], 'mkdir', lpath)

    self.state.add({
      rpath : wc.StateItem(status='A ')
    })
Exemplo n.º 7
0
 def svn_commit(self, rpath='', log=''):
     "Commit a WC path (recursively). Return the new revision number."
     lpath = local_path(rpath)
     actions.run_and_verify_svn(verify.AnyOutput, [], 'commit', '-m', log,
                                lpath)
     actions.run_and_verify_update(lpath, None, None, None)
     self.repo.head_rev += 1
     return self.repo.head_rev
Exemplo n.º 8
0
 def svn_commit(self, rpath='', log=''):
   "Commit a WC path (recursively). Return the new revision number."
   lpath = local_path(rpath)
   actions.run_and_verify_svn(None, verify.AnyOutput, [],
                              'commit', '-m', log, lpath)
   actions.run_and_verify_update(lpath, None, None, None)
   self.repo.head_rev += 1
   return self.repo.head_rev
Exemplo n.º 9
0
 def svn_mkdirs(self, *dirs):
     """Run 'svn mkdir' on the repository. DIRS is a list of directories to
 make, and each directory is a path relative to the repository root,
 neither starting nor ending with a slash."""
     urls = [self.repo_url + '/' + dir for dir in dirs]
     actions.run_and_verify_svn(None, [], 'mkdir', '-m', 'svn_mkdirs()',
                                '--parents', *urls)
     self.head_rev += 1
Exemplo n.º 10
0
def check_mergeinfo_recursively(root_path, subpaths_mergeinfo):
    """Check that the mergeinfo properties on and under ROOT_PATH are those in
     SUBPATHS_MERGEINFO, a {path: mergeinfo-prop-val} dictionary."""
    expected = verify.UnorderedOutput([
        path + ' - ' + subpaths_mergeinfo[path] + '\n'
        for path in subpaths_mergeinfo
    ])
    actions.run_and_verify_svn(expected, [], 'propget', '-R',
                               SVN_PROP_MERGEINFO, root_path)
Exemplo n.º 11
0
def check_mergeinfo_recursively(root_path, subpaths_mergeinfo):
  """Check that the mergeinfo properties on and under ROOT_PATH are those in
     SUBPATHS_MERGEINFO, a {path: mergeinfo-prop-val} dictionary."""
  expected = verify.UnorderedOutput(
    [path + ' - ' + subpaths_mergeinfo[path] + '\n'
     for path in subpaths_mergeinfo])
  actions.run_and_verify_svn(expected, [],
                                     'propget', '-R', SVN_PROP_MERGEINFO,
                                     root_path)
Exemplo n.º 12
0
def svn_mkfile(path):
  "Make and add a file with some default content, and keyword expansion."
  path = local_path(path)
  dirname, filename = os.path.split(path)
  main.file_write(path, "This is the file '" + filename + "'.\n" +
                                "Last changed in '$Revision$'.\n")
  actions.run_and_verify_svn(None, [], 'add', path)
  actions.run_and_verify_svn(None, [], 'propset',
                                     'svn:keywords', 'Revision', path)
Exemplo n.º 13
0
 def svn_mkdirs(self, *dirs):
   """Run 'svn mkdir' on the repository. DIRS is a list of directories to
   make, and each directory is a path relative to the repository root,
   neither starting nor ending with a slash."""
   urls = [self.repo_url + '/' + dir for dir in dirs]
   actions.run_and_verify_svn(None, None, [],
                              'mkdir', '-m', 'svn_mkdirs()', '--parents',
                              *urls)
   self.head_rev += 1
Exemplo n.º 14
0
def svn_mkfile(path):
  "Make and add a file with some default content, and keyword expansion."
  path = local_path(path)
  dirname, filename = os.path.split(path)
  main.file_write(path, "This is the file '" + filename + "'.\n" +
                                "Last changed in '$Revision$'.\n")
  actions.run_and_verify_svn(None, [], 'add', path)
  actions.run_and_verify_svn(None, [], 'propset',
                                     'svn:keywords', 'Revision', path)
Exemplo n.º 15
0
def svn_merge(rev_range,
              source,
              target,
              lines=None,
              elides=[],
              text_conflicts=0,
              prop_conflicts=0,
              tree_conflicts=0,
              text_resolved=0,
              prop_resolved=0,
              tree_resolved=0,
              args=[]):
    """Merge a single change from path SOURCE to path TARGET and verify the
  output and that there is no error.  (The changes made are not verified.)

  REV_RANGE is either a number (to cherry-pick that specific change) or a
  two-element list [X,Y] to pick the revision range '-r(X-1):Y'.

  LINES is a list of regular expressions to match other lines of output; if
  LINES is 'None' then match all normal (non-conflicting) merges.

  ELIDES is a list of paths on which mergeinfo elision should be reported.

  TEXT_CONFLICTS, PROP_CONFLICTS and TREE_CONFLICTS specify the number of
  each kind of conflict to expect.

  ARGS are additional arguments passed to svn merge.
  """

    source = local_path(source)
    target = local_path(target)
    elides = [local_path(p) for p in elides]
    if isinstance(rev_range, int):
        mi_rev_range = [rev_range]
        rev_arg = '-c' + str(rev_range)
    else:
        mi_rev_range = rev_range
        rev_arg = '-r' + str(rev_range[0] - 1) + ':' + str(rev_range[1])
    if lines is None:
        lines = ["(A |D |[UG] | [UG]|[UG][UG])   " + target + ".*\n"]
    else:
        # Expect mergeinfo on the target; caller must supply matches for any
        # subtree mergeinfo paths.
        lines.append(" [UG]   " + target + "\n")
    exp_out = expected_merge_output([mi_rev_range],
                                    lines,
                                    target=target,
                                    elides=elides,
                                    text_conflicts=text_conflicts,
                                    prop_conflicts=prop_conflicts,
                                    tree_conflicts=tree_conflicts,
                                    text_resolved=text_resolved,
                                    prop_resolved=prop_resolved,
                                    tree_resolved=tree_resolved)
    actions.run_and_verify_svn(exp_out, [], 'merge', rev_arg, source, target,
                               '--accept=postpone', *args)
Exemplo n.º 16
0
 def svn_set_props(self, rpath, props):
   """Change the properties of PATH to be the dictionary {name -> value} PROPS.
   """
   lpath = local_path(rpath)
   #for prop in path's existing props:
   #  actions.run_and_verify_svn(None, None, [], 'propdel',
   #                             prop, lpath)
   for prop in props:
     actions.run_and_verify_svn(None, None, [], 'propset',
                                prop, props[prop], lpath)
   self.state.tweak(rpath, props=props)
Exemplo n.º 17
0
 def svn_set_props(self, rpath, props):
     """Change the properties of PATH to be the dictionary {name -> value} PROPS.
 """
     lpath = local_path(rpath)
     #for prop in path's existing props:
     #  actions.run_and_verify_svn(None, [], 'propdel',
     #                             prop, lpath)
     for prop in props:
         actions.run_and_verify_svn(None, [], 'propset', prop, props[prop],
                                    lpath)
     self.state.tweak(rpath, props=props)
Exemplo n.º 18
0
 def svn_move(self, rpath1, rpath2, parents=False):
     """Move/rename the existing WC item RPATH1 to become RPATH2.
 RPATH2 must not already exist. If PARENTS is true, any missing parents
 of RPATH2 will be created."""
     lpath1 = local_path(rpath1)
     lpath2 = local_path(rpath2)
     args = [lpath1, lpath2]
     if parents:
         args += ['--parents']
     actions.run_and_verify_svn(None, [], 'copy', *args)
     self.state.add({rpath2: self.state.desc[rpath1]})
     self.state.remove(rpath1)
Exemplo n.º 19
0
def run_svn(sbox, expected_status, expected_stderr, *varargs):
  if expected_stderr is None:
    expected_stderr = []

  cwd = os.getcwd()
  try:
    os.chdir(sbox.wc_dir)
    actions.run_and_verify_svn(None, expected_stderr, *varargs)
  finally:
    os.chdir(cwd)

  if expected_status is not None:
    actions.run_and_verify_status(sbox.wc_dir, expected_status)
Exemplo n.º 20
0
def run_svn(sbox, expected_status, expected_stderr, *varargs):
    if expected_stderr is None:
        expected_stderr = []

    cwd = os.getcwd()
    try:
        os.chdir(sbox.wc_dir)
        actions.run_and_verify_svn(None, expected_stderr, *varargs)
    finally:
        os.chdir(cwd)

    if expected_status is not None:
        actions.run_and_verify_status(sbox.wc_dir, expected_status)
Exemplo n.º 21
0
 def svn_move(self, rpath1, rpath2, parents=False):
   """Move/rename the existing WC item RPATH1 to become RPATH2.
   RPATH2 must not already exist. If PARENTS is true, any missing parents
   of RPATH2 will be created."""
   lpath1 = local_path(rpath1)
   lpath2 = local_path(rpath2)
   args = [lpath1, lpath2]
   if parents:
     args += ['--parents']
   actions.run_and_verify_svn(None, None, [], 'copy', *args)
   self.state.add({
     rpath2: self.state.desc[rpath1]
   })
   self.state.remove(rpath1)
Exemplo n.º 22
0
 def svn_copy(self, rpath1, rpath2, parents=False, rev=None):
     """Copy the existing WC item RPATH1 to become RPATH2.
 RPATH2 must not already exist. If PARENTS is true, any missing parents
 of RPATH2 will be created. If REV is not None, copy revision REV of
 the node identified by WC item RPATH1."""
     lpath1 = local_path(rpath1)
     lpath2 = local_path(rpath2)
     args = [lpath1, lpath2]
     if rev is not None:
         args += ['-r', rev]
     if parents:
         args += ['--parents']
     actions.run_and_verify_svn(None, [], 'copy', *args)
     self.state.add({rpath2: self.state.desc[rpath1]})
Exemplo n.º 23
0
    def svn_file_create_add(self, rpath, content=None, props=None):
        "Make and add a file with some default content, and keyword expansion."
        lpath = local_path(rpath)
        ldirname, filename = os.path.split(lpath)
        if content is None:
            # Default content
            content = "This is the file '" + filename + "'.\n" + \
                      "Last changed in '$Revision$'.\n"
        main.file_write(lpath, content)
        actions.run_and_verify_svn(None, [], 'add', lpath)

        self.state.add({rpath: wc.StateItem(status='A ')})
        if props is None:
            # Default props
            props = {'svn:keywords': 'Revision'}
        self.svn_set_props(rpath, props)
Exemplo n.º 24
0
 def svn_copy(self, rpath1, rpath2, parents=False, rev=None):
   """Copy the existing WC item RPATH1 to become RPATH2.
   RPATH2 must not already exist. If PARENTS is true, any missing parents
   of RPATH2 will be created. If REV is not None, copy revision REV of
   the node identified by WC item RPATH1."""
   lpath1 = local_path(rpath1)
   lpath2 = local_path(rpath2)
   args = [lpath1, lpath2]
   if rev is not None:
     args += ['-r', rev]
   if parents:
     args += ['--parents']
   actions.run_and_verify_svn(None, None, [], 'copy', *args)
   self.state.add({
     rpath2: self.state.desc[rpath1]
   })
Exemplo n.º 25
0
def svn_merge(rev_range, source, target, lines=None, elides=[],
              text_conflicts=0, prop_conflicts=0, tree_conflicts=0,
              text_resolved=0, prop_resolved=0, tree_resolved=0,
              args=[]):
  """Merge a single change from path SOURCE to path TARGET and verify the
  output and that there is no error.  (The changes made are not verified.)

  REV_RANGE is either a number (to cherry-pick that specific change) or a
  two-element list [X,Y] to pick the revision range '-r(X-1):Y'.

  LINES is a list of regular expressions to match other lines of output; if
  LINES is 'None' then match all normal (non-conflicting) merges.

  ELIDES is a list of paths on which mergeinfo elision should be reported.

  TEXT_CONFLICTS, PROP_CONFLICTS and TREE_CONFLICTS specify the number of
  each kind of conflict to expect.

  ARGS are additional arguments passed to svn merge.
  """

  source = local_path(source)
  target = local_path(target)
  elides = [local_path(p) for p in elides]
  if isinstance(rev_range, int):
    mi_rev_range = [rev_range]
    rev_arg = '-c' + str(rev_range)
  else:
    mi_rev_range = rev_range
    rev_arg = '-r' + str(rev_range[0] - 1) + ':' + str(rev_range[1])
  if lines is None:
    lines = ["(A |D |[UG] | [UG]|[UG][UG])   " + target + ".*\n"]
  else:
    # Expect mergeinfo on the target; caller must supply matches for any
    # subtree mergeinfo paths.
    lines.append(" [UG]   " + target + "\n")
  exp_out = expected_merge_output([mi_rev_range], lines, target=target,
                                  elides=elides,
                                  text_conflicts=text_conflicts,
                                  prop_conflicts=prop_conflicts,
                                  tree_conflicts=tree_conflicts,
                                  text_resolved=text_resolved,
                                  prop_resolved=prop_resolved,
                                  tree_resolved=tree_resolved)
  actions.run_and_verify_svn(exp_out, [],
                                     'merge', rev_arg, source, target,
                                     '--accept=postpone', *args)
Exemplo n.º 26
0
    def copy_A(dest_name, rev):
        expected = verify.UnorderedOutput([
            "A         " + sbox.ospath(path_join(dest_name, p)) + "\n"
            for p in A_paths
        ])
        expected_status.add({
            path_join(dest_name, p): Item(status='  ', wc_rev=rev)
            for p in A_paths
        })
        expected_disk.add(
            {path_join(dest_name, p): greek_file_item(p)
             for p in A_paths})

        # Make a branch A_COPY to merge into.
        actions.run_and_verify_svn(expected, [], 'copy', sbox.repo_url + "/A",
                                   os.path.join(wc_dir, dest_name))

        expected_output = wc.State(wc_dir, {dest_name: Item(verb='Adding')})
        actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
Exemplo n.º 27
0
  def copy_A(dest_name, rev):
    expected = verify.UnorderedOutput(
      [ "A         " + sbox.ospath(path_join(dest_name, p)) + "\n"
        for p in A_paths ])
    expected_status.add(
      { path_join(dest_name, p) : Item(status='  ', wc_rev=rev)
        for p in A_paths })
    expected_disk.add(
      { path_join(dest_name, p) : greek_file_item(p)
        for p in A_paths })

    # Make a branch A_COPY to merge into.
    actions.run_and_verify_svn(expected, [], 'copy',
                                       sbox.repo_url + "/A",
                                       os.path.join(wc_dir,
                                                    dest_name))

    expected_output = wc.State(wc_dir, {dest_name : Item(verb='Adding')})
    actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
Exemplo n.º 28
0
  def svn_file_create_add(self, rpath, content=None, props=None):
    "Make and add a file with some default content, and keyword expansion."
    lpath = local_path(rpath)
    ldirname, filename = os.path.split(lpath)
    if content is None:
      # Default content
      content = "This is the file '" + filename + "'.\n" + \
                "Last changed in '$Revision$'.\n"
    main.file_write(lpath, content)
    actions.run_and_verify_svn(None, None, [], 'add', lpath)

    self.state.add({
      rpath : wc.StateItem(status='A ')
    })
    if props is None:
      # Default props
      props = {
        'svn:keywords': 'Revision'
      }
    self.svn_set_props(rpath, props)
Exemplo n.º 29
0
def set_up_repos(wc_dir, br_dir, scenarios):

  if not os.path.exists(br_dir):
    main.run_svn(None, "mkdir", "--parents", br_dir)

  # create the file F1 and dir D1 which the tests regard as pre-existing
  paths = incoming_paths(wc_dir, wc_dir)  # second arg is bogus but unimportant
  F1 = paths['F1']  # existing file to copy from
  main.file_write(F1, "This is initially file F1.\n")
  main.run_svn(None, 'add', F1)
  D1 = paths['D1']  # existing dir to copy from
  main.run_svn(None, 'mkdir', D1)

  # create the initial parent dirs, and each file or dir unless to-be-added
  for init_mods, action_mods in scenarios:
    path = "_".join(action_mods)
    P = os.path.join(br_dir, path)  # parent of items to be tested
    main.run_svn(None, 'mkdir', '--parents', P)
    for modaction in init_mods:
      modify(modaction, incoming_paths(wc_dir, P))
  run_and_verify_svn(None, AnyOutput, [],
                     'commit', '-m', 'Initial set-up.', wc_dir)
  # Capture the revision number
  init_rev = 2  ### hard-coded

  # modify all files and dirs in their various ways
  for _path, action_mods in scenarios:
    path = "_".join(action_mods)
    P = os.path.join(br_dir, path)  # parent
    for modaction in action_mods:
      modify(modaction, incoming_paths(wc_dir, P))

  # commit all the modifications
  run_and_verify_svn(None, AnyOutput, [],
                     'commit', '-m', 'Action.', wc_dir)
  # Capture the revision number
  changed_rev = 3  ### hard-coded

  return (init_rev, changed_rev)
def set_up_repos(wc_dir, br_dir, scenarios):

    if not os.path.exists(br_dir):
        main.run_svn(None, "mkdir", "--parents", br_dir)

    # create the file F1 and dir D1 which the tests regard as pre-existing
    paths = incoming_paths(wc_dir, wc_dir)  # second arg is bogus but unimportant
    F1 = paths["F1"]  # existing file to copy from
    main.file_write(F1, "This is initially file F1.\n")
    main.run_svn(None, "add", F1)
    D1 = paths["D1"]  # existing dir to copy from
    main.run_svn(None, "mkdir", D1)

    # create the initial parent dirs, and each file or dir unless to-be-added
    for init_mods, action_mods in scenarios:
        path = "_".join(action_mods)
        P = os.path.join(br_dir, path)  # parent of items to be tested
        main.run_svn(None, "mkdir", "--parents", P)
        for modaction in init_mods:
            modify(modaction, incoming_paths(wc_dir, P))
    run_and_verify_svn(None, AnyOutput, [], "commit", "-m", "Initial set-up.", wc_dir)
    # Capture the revision number
    init_rev = 2  ### hard-coded

    # modify all files and dirs in their various ways
    for _path, action_mods in scenarios:
        path = "_".join(action_mods)
        P = os.path.join(br_dir, path)  # parent
        for modaction in action_mods:
            modify(modaction, incoming_paths(wc_dir, P))

    # commit all the modifications
    run_and_verify_svn(None, AnyOutput, [], "commit", "-m", "Action.", wc_dir)
    # Capture the revision number
    changed_rev = 3  ### hard-coded

    return (init_rev, changed_rev)
Exemplo n.º 31
0
def get_mergeinfo_change(sbox, target):
  """Return a list of revision numbers representing the mergeinfo change
  on TARGET (working version against base).  Non-recursive."""
  exit, out, err = actions.run_and_verify_svn(None, None, [],
                                              'diff', '--depth=empty',
                                              sbox.ospath(target))
  merged_revs = []
  for line in out:
    match = re.match(r'   Merged /(\w+):r(.*)', line)
    if match:
      for r_range in match.group(2).split(','):
        if '-' in r_range:
          r_start, r_end = r_range.split('-')
        else:
          r_start = r_end = r_range
        merged_revs += range(int(r_start), int(r_end) + 1)
  return merged_revs
def get_mergeinfo_change(sbox, target):
    """Return a list of revision numbers representing the mergeinfo change
  on TARGET (working version against base).  Non-recursive."""
    exit, out, err = actions.run_and_verify_svn(None, [], 'diff',
                                                '--depth=empty',
                                                sbox.ospath(target))
    merged_revs = []
    for line in out:
        match = re.match(r'   Merged /(\w+):r(.*)', line)
        if match:
            for r_range in match.group(2).split(','):
                if '-' in r_range:
                    r_start, r_end = r_range.split('-')
                else:
                    r_start = r_end = r_range
                merged_revs += range(int(r_start), int(r_end) + 1)
    return merged_revs
Exemplo n.º 33
0
def set_up_dir_replace(sbox):
    """Set up the working copy for directory replace tests, creating
  directory 'A/B/F/foo' with files 'new file' and 'new file2' within
  it (r2), and merging 'foo' onto 'C' (r3), then deleting 'A/B/F/foo'
  (r4)."""

    sbox.build()
    wc_dir = sbox.wc_dir

    C_path = sbox.ospath('A/C')
    F_path = sbox.ospath('A/B/F')
    F_url = sbox.repo_url + '/A/B/F'

    foo_path = os.path.join(F_path, 'foo')
    new_file = os.path.join(foo_path, "new file")
    new_file2 = os.path.join(foo_path, "new file 2")

    # Make directory foo in F, and add some files within it.
    actions.run_and_verify_svn(None, [], 'mkdir', foo_path)
    main.file_append(new_file, "Initial text in new file.\n")
    main.file_append(new_file2, "Initial text in new file 2.\n")
    main.run_svn(None, "add", new_file)
    main.run_svn(None, "add", new_file2)

    # Commit all the new content, creating r2.
    expected_output = wc.State(
        wc_dir, {
            'A/B/F/foo': Item(verb='Adding'),
            'A/B/F/foo/new file': Item(verb='Adding'),
            'A/B/F/foo/new file 2': Item(verb='Adding'),
        })
    expected_status = actions.get_virginal_state(wc_dir, 1)
    expected_status.add({
        'A/B/F/foo': Item(status='  ', wc_rev=2),
        'A/B/F/foo/new file': Item(status='  ', wc_rev=2),
        'A/B/F/foo/new file 2': Item(status='  ', wc_rev=2),
    })
    actions.run_and_verify_commit(wc_dir, expected_output, expected_status)

    # Merge foo onto C
    expected_output = wc.State(
        C_path, {
            'foo': Item(status='A '),
            'foo/new file': Item(status='A '),
            'foo/new file 2': Item(status='A '),
        })
    expected_mergeinfo_output = wc.State(C_path, {
        '': Item(status=' U'),
    })
    expected_elision_output = wc.State(C_path, {})
    expected_disk = wc.State(
        '', {
            '': Item(props={SVN_PROP_MERGEINFO: '/A/B/F:2'}),
            'foo': Item(),
            'foo/new file': Item("Initial text in new file.\n"),
            'foo/new file 2': Item("Initial text in new file 2.\n"),
        })
    expected_status = wc.State(
        C_path, {
            '': Item(status=' M', wc_rev=1),
            'foo': Item(status='A ', wc_rev='-', copied='+'),
            'foo/new file': Item(status='  ', wc_rev='-', copied='+'),
            'foo/new file 2': Item(status='  ', wc_rev='-', copied='+'),
        })
    expected_skip = wc.State(C_path, {})
    actions.run_and_verify_merge(C_path,
                                 '1',
                                 '2',
                                 F_url,
                                 None,
                                 expected_output,
                                 expected_mergeinfo_output,
                                 expected_elision_output,
                                 expected_disk,
                                 expected_status,
                                 expected_skip,
                                 check_props=True)
    # Commit merge of foo onto C, creating r3.
    expected_output = wc.State(wc_dir, {
        'A/C': Item(verb='Sending'),
        'A/C/foo': Item(verb='Adding'),
    })
    expected_status = actions.get_virginal_state(wc_dir, 1)
    expected_status.add({
        'A/B/F/foo': Item(status='  ', wc_rev=2),
        'A/C': Item(status='  ', wc_rev=3),
        'A/B/F/foo/new file': Item(status='  ', wc_rev=2),
        'A/B/F/foo/new file 2': Item(status='  ', wc_rev=2),
        'A/C/foo': Item(status='  ', wc_rev=3),
        'A/C/foo/new file': Item(status='  ', wc_rev=3),
        'A/C/foo/new file 2': Item(status='  ', wc_rev=3),
    })
    actions.run_and_verify_commit(wc_dir, expected_output, expected_status)

    # Delete foo on F, creating r4.
    actions.run_and_verify_svn(None, [], 'rm', foo_path)
    expected_output = wc.State(wc_dir, {
        'A/B/F/foo': Item(verb='Deleting'),
    })
    expected_status = actions.get_virginal_state(wc_dir, 1)
    expected_status.add({
        'A/C': Item(status='  ', wc_rev=3),
        'A/C/foo': Item(status='  ', wc_rev=3),
        'A/C/foo/new file': Item(status='  ', wc_rev=3),
        'A/C/foo/new file 2': Item(status='  ', wc_rev=3),
    })
    actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
Exemplo n.º 34
0
def svn_copy(s_rev, path1, path2):
    "Copy a WC path locally."
    path1 = local_path(path1)
    path2 = local_path(path2)
    actions.run_and_verify_svn(None, [], 'copy', '--parents', '-r', s_rev,
                               path1, path2)
def ensure_tree_conflict(sbox, operation, incoming_scenarios, localmod_scenarios, commit_local_mods):
    sbox.build()
    wc_dir = sbox.wc_dir

    def url_of(repo_relative_path):
        return sbox.repo_url + "/" + repo_relative_path

    verbose_print("")
    verbose_print("=== Starting a set of '" + operation + "' tests.")

    # Path to source branch, relative to wc_dir.
    # Source is where the "incoming" mods are made.
    source_br = "branch1"

    verbose_print("--- Creating changes in repos")
    source_wc_dir = os.path.join(wc_dir, source_br)
    source_left_rev, source_right_rev = set_up_repos(wc_dir, source_wc_dir, incoming_scenarios)
    head_rev = source_right_rev  ### assumption

    # Local mods are the outer loop because cleaning up the WC is slow
    # ('svn revert' isn't sufficient because it leaves unversioned files)
    for _loc_init_mods, loc_action in localmod_scenarios:
        # Determine the branch (directory) in which local mods will be made.
        if operation == "update":
            # Path to target branch (where conflicts are raised), relative to wc_dir.
            target_br = source_br
            target_start_rev = source_left_rev
        else:  # switch/merge
            # Make, and work in, a "branch2" that is a copy of "branch1".
            target_br = "branch2"
            run_and_verify_svn(
                None,
                AnyOutput,
                [],
                "copy",
                "-r",
                str(source_left_rev),
                url_of(source_br),
                url_of(target_br),
                "-m",
                "Create target branch.",
            )
            head_rev += 1
            target_start_rev = head_rev

        main.run_svn(None, "checkout", "-r", str(target_start_rev), sbox.repo_url, wc_dir)

        saved_cwd = os.getcwd()
        os.chdir(wc_dir)

        for _inc_init_mods, inc_action in incoming_scenarios:
            scen_name = "_".join(inc_action)
            source_url = url_of(source_br + "/" + scen_name)
            target_path = os.path.join(target_br, scen_name)

            verbose_print("=== " + str(inc_action) + " onto " + str(loc_action))

            verbose_print("--- Making local mods")
            for modaction in loc_action:
                modify(modaction, localmod_paths(".", target_path))
            if commit_local_mods:
                run_and_verify_svn(None, AnyOutput, [], "commit", target_path, "-m", "Mods in target branch.")
                head_rev += 1

            # What do we want to test for? (This selection could in future be
            # passed in to this function as a parameter.)
            test_what = [
                "commit-ood",
                "action",  # required for any of the following ones to work
                "notify",
                "commit-c",
                "status-c",
                "resolve",  # required for any of the following ones to work
                "status-nc",
                #'commit-ok',
            ]

            if "commit-ood" in test_what:
                # For update, verify the pre-condition that WC is out of date.
                # For switch/merge, there is no such precondition.
                if operation == "update":
                    verbose_print("--- Trying to commit (expecting 'out-of-date' error)")
                    run_and_verify_commit(".", None, None, "Commit failed", target_path)

            if modaction.startswith("f"):
                victim = os.path.join(target_path, "F")
            else:
                victim = os.path.join(target_path, "D")

            # Perform the operation that tries to apply incoming changes to the WC.
            # The command is expected to do something (and give some output),
            # and it should raise a conflict but not an error.
            if "action" in test_what:
                # Determine what notification to expect
                if "notify" in test_what:
                    expected_stdout = svntest.verify.ExpectedOutput("   C " + victim + "\n", match_all=False)
                else:
                    expected_stdout = svntest.verify.AnyOutput
                # Do the main action
                if operation == "update":
                    verbose_print("--- Updating")
                    run_and_verify_svn(None, expected_stdout, [], "update", target_path)
                elif operation == "switch":
                    verbose_print("--- Switching")
                    run_and_verify_svn(None, expected_stdout, [], "switch", source_url, target_path)
                elif operation == "merge":
                    verbose_print("--- Merging")
                    run_and_verify_svn(
                        None,
                        expected_stdout,
                        [],
                        "merge",
                        "--ignore-ancestry",
                        "-r",
                        str(source_left_rev) + ":" + str(source_right_rev),
                        source_url,
                        target_path,
                    )
                else:
                    raise Exception("unknown operation: '" + operation + "'")

            if "commit-c" in test_what:
                verbose_print("--- Trying to commit (expecting 'conflict' error)")
                ### run_and_verify_commit() requires an "output_tree" argument, but
                # here we get away with passing None because we know an implementation
                # detail: namely that it's not going to look at that argument if it
                # gets the stderr that we're expecting.
                run_and_verify_commit(".", None, None, ".*conflict.*", victim)

            if "status-c" in test_what:
                verbose_print("--- Checking that 'status' reports the conflict")
                expected_stdout = svntest.verify.RegexOutput("^......C.* " + re.escape(victim) + "$", match_all=False)
                run_and_verify_svn(None, expected_stdout, [], "status", victim)

            if "resolve" in test_what:
                verbose_print("--- Resolving the conflict")
                # Make sure resolving the parent does nothing.
                run_and_verify_resolved([], os.path.dirname(victim))
                # The real resolved call.
                run_and_verify_resolved([victim])

            if "status-nc" in test_what:
                verbose_print("--- Checking that 'status' does not report a conflict")
                exitcode, stdout, stderr = run_and_verify_svn(None, None, [], "status", victim)
                for line in stdout:
                    if line[6] == "C":  # and line.endswith(victim + '\n'):
                        raise svntest.Failure("unexpected status C")  # on path '" + victim + "'")

            if "commit-ok" in test_what:
                verbose_print("--- Committing (should now succeed)")
                run_and_verify_svn(None, None, [], "commit", "-m", "", target_path)
                target_start_rev += 1

            verbose_print("")

        os.chdir(saved_cwd)

        # Clean up the target branch and WC
        main.run_svn(None, "revert", "-R", wc_dir)
        main.safe_rmtree(wc_dir)
        if operation != "update":
            run_and_verify_svn(None, AnyOutput, [], "delete", url_of(target_br), "-m", "Delete target branch.")
            head_rev += 1
Exemplo n.º 36
0
def set_up_dir_replace(sbox):
  """Set up the working copy for directory replace tests, creating
  directory 'A/B/F/foo' with files 'new file' and 'new file2' within
  it (r2), and merging 'foo' onto 'C' (r3), then deleting 'A/B/F/foo'
  (r4)."""

  sbox.build()
  wc_dir = sbox.wc_dir

  C_path = sbox.ospath('A/C')
  F_path = sbox.ospath('A/B/F')
  F_url = sbox.repo_url + '/A/B/F'

  foo_path = os.path.join(F_path, 'foo')
  new_file = os.path.join(foo_path, "new file")
  new_file2 = os.path.join(foo_path, "new file 2")

  # Make directory foo in F, and add some files within it.
  actions.run_and_verify_svn(None, [], 'mkdir', foo_path)
  main.file_append(new_file, "Initial text in new file.\n")
  main.file_append(new_file2, "Initial text in new file 2.\n")
  main.run_svn(None, "add", new_file)
  main.run_svn(None, "add", new_file2)

  # Commit all the new content, creating r2.
  expected_output = wc.State(wc_dir, {
    'A/B/F/foo'            : Item(verb='Adding'),
    'A/B/F/foo/new file'   : Item(verb='Adding'),
    'A/B/F/foo/new file 2' : Item(verb='Adding'),
    })
  expected_status = actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'A/B/F/foo'             : Item(status='  ', wc_rev=2),
    'A/B/F/foo/new file'    : Item(status='  ', wc_rev=2),
    'A/B/F/foo/new file 2'  : Item(status='  ', wc_rev=2),
    })
  actions.run_and_verify_commit(wc_dir, expected_output, expected_status)

  # Merge foo onto C
  expected_output = wc.State(C_path, {
    'foo' : Item(status='A '),
    'foo/new file'   : Item(status='A '),
    'foo/new file 2' : Item(status='A '),
    })
  expected_mergeinfo_output = wc.State(C_path, {
    '' : Item(status=' U'),
    })
  expected_elision_output = wc.State(C_path, {
    })
  expected_disk = wc.State('', {
    ''               : Item(props={SVN_PROP_MERGEINFO : '/A/B/F:2'}),
    'foo' : Item(),
    'foo/new file'   : Item("Initial text in new file.\n"),
    'foo/new file 2' : Item("Initial text in new file 2.\n"),
    })
  expected_status = wc.State(C_path, {
    ''    : Item(status=' M', wc_rev=1),
    'foo' : Item(status='A ', wc_rev='-', copied='+'),
    'foo/new file'   : Item(status='  ', wc_rev='-', copied='+'),
    'foo/new file 2' : Item(status='  ', wc_rev='-', copied='+'),
    })
  expected_skip = wc.State(C_path, { })
  actions.run_and_verify_merge(C_path, '1', '2', F_url, None,
                                       expected_output,
                                       expected_mergeinfo_output,
                                       expected_elision_output,
                                       expected_disk,
                                       expected_status,
                                       expected_skip,
                                       check_props=True)
  # Commit merge of foo onto C, creating r3.
  expected_output = wc.State(wc_dir, {
    'A/C'        : Item(verb='Sending'),
    'A/C/foo'    : Item(verb='Adding'),
    })
  expected_status = actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'A/B/F/foo'  : Item(status='  ', wc_rev=2),
    'A/C'        : Item(status='  ', wc_rev=3),
    'A/B/F/foo/new file'      : Item(status='  ', wc_rev=2),
    'A/B/F/foo/new file 2'    : Item(status='  ', wc_rev=2),
    'A/C/foo'    : Item(status='  ', wc_rev=3),
    'A/C/foo/new file'      : Item(status='  ', wc_rev=3),
    'A/C/foo/new file 2'    : Item(status='  ', wc_rev=3),

    })
  actions.run_and_verify_commit(wc_dir, expected_output, expected_status)

  # Delete foo on F, creating r4.
  actions.run_and_verify_svn(None, [], 'rm', foo_path)
  expected_output = wc.State(wc_dir, {
    'A/B/F/foo'   : Item(verb='Deleting'),
    })
  expected_status = actions.get_virginal_state(wc_dir, 1)
  expected_status.add({
    'A/C'         : Item(status='  ', wc_rev=3),
    'A/C/foo'     : Item(status='  ', wc_rev=3),
    'A/C/foo/new file'      : Item(status='  ', wc_rev=3),
    'A/C/foo/new file 2'    : Item(status='  ', wc_rev=3),
    })
  actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
    def copy_A(dest_name, rev):
        expected = verify.UnorderedOutput([
            "A    " + os.path.join(wc_dir, dest_name, "B") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "B", "lambda") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "B", "E") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "B", "E", "alpha") +
            "\n", "A    " + os.path.join(wc_dir, dest_name, "B", "E", "beta") +
            "\n", "A    " + os.path.join(wc_dir, dest_name, "B", "F") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "mu") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "C") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "gamma") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "G") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "G", "pi") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "G", "rho") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "G", "tau") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "H") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "H", "chi") + "\n",
            "A    " + os.path.join(wc_dir, dest_name, "D", "H", "omega") +
            "\n", "A    " + os.path.join(wc_dir, dest_name, "D", "H", "psi") +
            "\n", "Checked out revision " + str(rev - 1) + ".\n",
            "A         " + os.path.join(wc_dir, dest_name) + "\n"
        ])
        expected_status.add({
            dest_name + "/B":
            Item(status='  ', wc_rev=rev),
            dest_name + "/B/lambda":
            Item(status='  ', wc_rev=rev),
            dest_name + "/B/E":
            Item(status='  ', wc_rev=rev),
            dest_name + "/B/E/alpha":
            Item(status='  ', wc_rev=rev),
            dest_name + "/B/E/beta":
            Item(status='  ', wc_rev=rev),
            dest_name + "/B/F":
            Item(status='  ', wc_rev=rev),
            dest_name + "/mu":
            Item(status='  ', wc_rev=rev),
            dest_name + "/C":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/gamma":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/G":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/G/pi":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/G/rho":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/G/tau":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/H":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/H/chi":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/H/omega":
            Item(status='  ', wc_rev=rev),
            dest_name + "/D/H/psi":
            Item(status='  ', wc_rev=rev),
            dest_name:
            Item(status='  ', wc_rev=rev)
        })
        expected_disk.add({
            dest_name:
            Item(),
            dest_name + '/B':
            Item(),
            dest_name + '/B/lambda':
            Item("This is the file 'lambda'.\n"),
            dest_name + '/B/E':
            Item(),
            dest_name + '/B/E/alpha':
            Item("This is the file 'alpha'.\n"),
            dest_name + '/B/E/beta':
            Item("This is the file 'beta'.\n"),
            dest_name + '/B/F':
            Item(),
            dest_name + '/mu':
            Item("This is the file 'mu'.\n"),
            dest_name + '/C':
            Item(),
            dest_name + '/D':
            Item(),
            dest_name + '/D/gamma':
            Item("This is the file 'gamma'.\n"),
            dest_name + '/D/G':
            Item(),
            dest_name + '/D/G/pi':
            Item("This is the file 'pi'.\n"),
            dest_name + '/D/G/rho':
            Item("This is the file 'rho'.\n"),
            dest_name + '/D/G/tau':
            Item("This is the file 'tau'.\n"),
            dest_name + '/D/H':
            Item(),
            dest_name + '/D/H/chi':
            Item("This is the file 'chi'.\n"),
            dest_name + '/D/H/omega':
            Item("This is the file 'omega'.\n"),
            dest_name + '/D/H/psi':
            Item("This is the file 'psi'.\n"),
        })

        # Make a branch A_COPY to merge into.
        actions.run_and_verify_svn(expected, [], 'copy', sbox.repo_url + "/A",
                                   os.path.join(wc_dir, dest_name))

        expected_output = wc.State(wc_dir, {dest_name: Item(verb='Adding')})
        actions.run_and_verify_commit(wc_dir, expected_output, expected_status)
Exemplo n.º 38
0
def svn_modfile(path):
  "Make text and property mods to a WC file."
  path = local_path(path)
  main.file_append(path, "An extra line.\n")
  actions.run_and_verify_svn(None, [], 'propset',
                                     'newprop', 'v', path)
Exemplo n.º 39
0
def ensure_tree_conflict(sbox, operation,
                         incoming_scenarios, localmod_scenarios,
                         commit_local_mods):
  sbox.build()
  wc_dir = sbox.wc_dir

  def url_of(repo_relative_path):
    return sbox.repo_url + '/' + repo_relative_path

  verbose_print("")
  verbose_print("=== Starting a set of '" + operation + "' tests.")

  # Path to source branch, relative to wc_dir.
  # Source is where the "incoming" mods are made.
  source_br = "branch1"

  verbose_print("--- Creating changes in repos")
  source_wc_dir = os.path.join(wc_dir, source_br)
  source_left_rev, source_right_rev = set_up_repos(wc_dir, source_wc_dir,
                                                   incoming_scenarios)
  head_rev = source_right_rev  ### assumption

  # Local mods are the outer loop because cleaning up the WC is slow
  # ('svn revert' isn't sufficient because it leaves unversioned files)
  for _loc_init_mods, loc_action in localmod_scenarios:
    # Determine the branch (directory) in which local mods will be made.
    if operation == 'update':
      # Path to target branch (where conflicts are raised), relative to wc_dir.
      target_br = source_br
      target_start_rev = source_left_rev
    else:  # switch/merge
      # Make, and work in, a "branch2" that is a copy of "branch1".
      target_br = "branch2"
      run_and_verify_svn(None, AnyOutput, [],
                         'copy', '-r', str(source_left_rev), url_of(source_br),
                         url_of(target_br),
                         '-m', 'Create target branch.')
      head_rev += 1
      target_start_rev = head_rev

    main.run_svn(None, 'checkout', '-r', str(target_start_rev), sbox.repo_url,
                 wc_dir)

    saved_cwd = os.getcwd()
    os.chdir(wc_dir)

    for _inc_init_mods, inc_action in incoming_scenarios:
      scen_name = "_".join(inc_action)
      source_url = url_of(source_br + '/' + scen_name)
      target_path = os.path.join(target_br, scen_name)

      verbose_print("=== " + str(inc_action) + " onto " + str(loc_action))

      verbose_print("--- Making local mods")
      for modaction in loc_action:
        modify(modaction, localmod_paths(".", target_path))
      if commit_local_mods:
        run_and_verify_svn(None, AnyOutput, [],
                           'commit', target_path,
                           '-m', 'Mods in target branch.')
        head_rev += 1

      # What do we want to test for? (This selection could in future be
      # passed in to this function as a parameter.)
      test_what = [
        'commit-ood',
        'action',  # required for any of the following ones to work
        'notify',
        'commit-c',
        'status-c',
        'resolve',  # required for any of the following ones to work
        'status-nc',
        #'commit-ok',
        ]

      if 'commit-ood' in test_what:
        # For update, verify the pre-condition that WC is out of date.
        # For switch/merge, there is no such precondition.
        if operation == 'update':
          verbose_print("--- Trying to commit (expecting 'out-of-date' error)")
          run_and_verify_commit(".", None, None, "Commit failed",
                                target_path)

      if modaction.startswith('f'):
        victim = os.path.join(target_path, 'F')
      else:
        victim = os.path.join(target_path, 'D')

      # Perform the operation that tries to apply incoming changes to the WC.
      # The command is expected to do something (and give some output),
      # and it should raise a conflict but not an error.
      if 'action' in test_what:
        # Determine what notification to expect
        if 'notify' in test_what:
          expected_stdout = svntest.verify.ExpectedOutput("   C " + victim
                                                          + "\n",
                                                          match_all=False)
        else:
          expected_stdout = svntest.verify.AnyOutput
        # Do the main action
        if operation == 'update':
          verbose_print("--- Updating")
          run_and_verify_svn(None, expected_stdout, [],
                             'update', target_path)
        elif operation == 'switch':
          verbose_print("--- Switching")
          run_and_verify_svn(None, expected_stdout, [],
                             'switch', source_url, target_path)
        elif operation == 'merge':
          verbose_print("--- Merging")
          run_and_verify_svn(None, expected_stdout, [],
                             'merge', '--ignore-ancestry',
                             '-r', str(source_left_rev) + ':' + str(source_right_rev),
                             source_url, target_path)
        else:
          raise Exception("unknown operation: '" + operation + "'")

      if 'commit-c' in test_what:
        verbose_print("--- Trying to commit (expecting 'conflict' error)")
        ### run_and_verify_commit() requires an "output_tree" argument, but
        # here we get away with passing None because we know an implementation
        # detail: namely that it's not going to look at that argument if it
        # gets the stderr that we're expecting.
        run_and_verify_commit(".", None, None, ".*conflict.*", victim)

      if 'status-c' in test_what:
        verbose_print("--- Checking that 'status' reports the conflict")
        expected_stdout = svntest.verify.RegexOutput("^......C.* " +
                                                     re.escape(victim) + "$",
                                                     match_all=False)
        run_and_verify_svn(None, expected_stdout, [],
                           'status', victim)

      if 'resolve' in test_what:
        verbose_print("--- Resolving the conflict")
        # Make sure resolving the parent does nothing.
        run_and_verify_resolved([], os.path.dirname(victim))
        # The real resolved call.
        run_and_verify_resolved([victim])

      if 'status-nc' in test_what:
        verbose_print("--- Checking that 'status' does not report a conflict")
        exitcode, stdout, stderr = run_and_verify_svn(None, None, [],
                                                  'status', victim)
        for line in stdout:
          if line[6] == 'C': # and line.endswith(victim + '\n'):
            raise svntest.Failure("unexpected status C") # on path '" + victim + "'")

      if 'commit-ok' in test_what:
        verbose_print("--- Committing (should now succeed)")
        run_and_verify_svn(None, None, [],
                           'commit', '-m', '', target_path)
        target_start_rev += 1

      verbose_print("")

    os.chdir(saved_cwd)

    # Clean up the target branch and WC
    main.run_svn(None, 'revert', '-R', wc_dir)
    main.safe_rmtree(wc_dir)
    if operation != 'update':
      run_and_verify_svn(None, AnyOutput, [],
                         'delete', url_of(target_br),
                         '-m', 'Delete target branch.')
      head_rev += 1
Exemplo n.º 40
0
def svn_copy(s_rev, path1, path2):
  "Copy a WC path locally."
  path1 = local_path(path1)
  path2 = local_path(path2)
  actions.run_and_verify_svn(None, [], 'copy', '--parents',
                                     '-r', s_rev, path1, path2)
Exemplo n.º 41
0
def svn_modfile(path):
    "Make text and property mods to a WC file."
    path = local_path(path)
    main.file_append(path, "An extra line.\n")
    actions.run_and_verify_svn(None, [], 'propset', 'newprop', 'v', path)