~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005 by Canonical Ltd

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

# 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

# (at your option) any later version.

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

# Mr. Smoketoomuch: I'm sorry?

# Mr. Bounder: You'd better cut down a little then.

# Mr. Smoketoomuch: Oh, I see! Smoke too much so I'd better cut down a little

#                   then!

"""Black-box tests for bzr.

These check that it behaves properly when it's invoked through the regular

command-line interface. This doesn't actually run a new interpreter but 

rather starts again from the run_bzr function.

"""

# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

# Note: Please don't add new tests here, it's too big and bulky.  Instead add

# them into small suites in bzrlib.tests.blackbox.test_FOO for the particular

# UI command/aspect that is being tested.

from cStringIO import StringIO

import os

import re

import sys

import bzrlib

from bzrlib.branch import Branch

import bzrlib.bzrdir as bzrdir

from bzrlib.errors import BzrCommandError

from bzrlib.osutils import (

    has_symlinks,

    pathjoin,

    rmtree,

    terminal_width,

    )

from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver

from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer

from bzrlib.tests.blackbox import ExternalBase

from bzrlib.workingtree import WorkingTree

class TestCommands(ExternalBase):

    def test_whoami(self):

        # this should always identify something, if only "john@localhost"

        self.runbzr("whoami")

        self.runbzr("whoami --email")

        self.assertEquals(self.runbzr("whoami --email",

                                      backtick=True).count('@'), 1)

    def test_whoami_branch(self):

        """branch specific user identity works."""

        self.runbzr('init')

        b = bzrlib.branch.Branch.open('.')

        b.control_files.put_utf8('email', 'Branch Identity <branch@identi.ty>')

        bzr_email = os.environ.get('BZREMAIL')

        if bzr_email is not None:

            del os.environ['BZREMAIL']

        whoami = self.runbzr("whoami",backtick=True)

        whoami_email = self.runbzr("whoami --email",backtick=True)

        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))

        self.assertTrue(whoami_email.startswith('branch@identi.ty'))

        # Verify that the environment variable overrides the value 

        # in the file

        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'

        whoami = self.runbzr("whoami",backtick=True)

        whoami_email = self.runbzr("whoami --email",backtick=True)

        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))

        self.assertTrue(whoami_email.startswith('other@environ.ment'))

        if bzr_email is not None:

            os.environ['BZREMAIL'] = bzr_email

    def test_nick_command(self):

        """bzr nick for viewing, setting nicknames"""

        os.mkdir('me.dev')

        os.chdir('me.dev')

        self.runbzr('init')

        nick = self.runbzr("nick",backtick=True)

        self.assertEqual(nick, 'me.dev\n')

        nick = self.runbzr("nick moo")

        nick = self.runbzr("nick",backtick=True)

        self.assertEqual(nick, 'moo\n')

    def test_invalid_commands(self):

        self.runbzr("pants", retcode=3)

        self.runbzr("--pants off", retcode=3)

        self.runbzr("diff --message foo", retcode=3)

    def test_ignore_patterns(self):

        self.runbzr('init')

        self.assertEquals(self.capture('unknowns'), '')

        file('foo.tmp', 'wt').write('tmp files are ignored')

        self.assertEquals(self.capture('unknowns'), '')

        file('foo.c', 'wt').write('int main() {}')

        self.assertEquals(self.capture('unknowns'), 'foo.c\n')

        self.runbzr(['add', 'foo.c'])

        self.assertEquals(self.capture('unknowns'), '')

        # 'ignore' works when creating the .bzignore file

        file('foo.blah', 'wt').write('blah')

        self.assertEquals(self.capture('unknowns'), 'foo.blah\n')

        self.runbzr('ignore *.blah')

        self.assertEquals(self.capture('unknowns'), '')

        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')

        # 'ignore' works when then .bzrignore file already exists

        file('garh', 'wt').write('garh')

        self.assertEquals(self.capture('unknowns'), 'garh\n')

        self.runbzr('ignore garh')

        self.assertEquals(self.capture('unknowns'), '')

        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')

    def test_mv_modes(self):

        """Test two modes of operation for mv"""

        self.runbzr('init')

        self.build_tree(['a', 'c', 'subdir/'])

        self.run_bzr_captured(['add', self.test_dir])

        self.run_bzr_captured(['mv', 'a', 'b'])

        self.run_bzr_captured(['mv', 'b', 'subdir'])

        self.run_bzr_captured(['mv', 'subdir/b', 'a'])

        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])

        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])

    def test_main_version(self):

        """Check output from version command and master option is reasonable"""

        # output is intentionally passed through to stdout so that we

        # can see the version being tested

        output = self.runbzr('version', backtick=1)

        self.log('bzr version output:')

        self.log(output)

        self.assert_(output.startswith('bzr (bazaar-ng) '))

        self.assertNotEqual(output.index('Canonical'), -1)

        # make sure --version is consistent

        tmp_output = self.runbzr('--version', backtick=1)

        self.log('bzr --version output:')

        self.log(tmp_output)

        self.assertEquals(output, tmp_output)

    def example_branch(test):

        test.runbzr('init')

        file('hello', 'wt').write('foo')

        test.runbzr('add hello')

        test.runbzr('commit -m setup hello')

        file('goodbye', 'wt').write('baz')

        test.runbzr('add goodbye')

        test.runbzr('commit -m setup goodbye')

    def test_export(self):

        os.mkdir('branch')

        os.chdir('branch')

        self.example_branch()

        self.runbzr('export ../latest')

        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')

        self.runbzr('export ../first -r 1')

        self.assert_(not os.path.exists('../first/goodbye'))

        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')

        self.runbzr('export ../first.gz -r 1')

        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')

        self.runbzr('export ../first.bz2 -r 1')

        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')

        from tarfile import TarFile

        self.runbzr('export ../first.tar -r 1')

        self.assert_(os.path.isfile('../first.tar'))

        tf = TarFile('../first.tar')

        self.assert_('first/hello' in tf.getnames(), tf.getnames())

        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')

        self.runbzr('export ../first.tar.gz -r 1')

        self.assert_(os.path.isfile('../first.tar.gz'))

        self.runbzr('export ../first.tbz2 -r 1')

        self.assert_(os.path.isfile('../first.tbz2'))

        self.runbzr('export ../first.tar.bz2 -r 1')

        self.assert_(os.path.isfile('../first.tar.bz2'))

        self.runbzr('export ../first.tar.tbz2 -r 1')

        self.assert_(os.path.isfile('../first.tar.tbz2'))

        from bz2 import BZ2File

        tf = TarFile('../first.tar.tbz2', 

                     fileobj=BZ2File('../first.tar.tbz2', 'r'))

        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())

        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')

        self.runbzr('export ../first2.tar -r 1 --root pizza')

        tf = TarFile('../first2.tar')

        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())

        from zipfile import ZipFile

        self.runbzr('export ../first.zip -r 1')

        self.failUnlessExists('../first.zip')

        zf = ZipFile('../first.zip')

        self.assert_('first/hello' in zf.namelist(), zf.namelist())

        self.assertEqual(zf.read('first/hello'), 'foo')

        self.runbzr('export ../first2.zip -r 1 --root pizza')

        zf = ZipFile('../first2.zip')

        self.assert_('pizza/hello' in zf.namelist(), zf.namelist())

        self.runbzr('export ../first-zip --format=zip -r 1')

        zf = ZipFile('../first-zip')

        self.assert_('first-zip/hello' in zf.namelist(), zf.namelist())

    def test_inventory(self):

        bzr = self.runbzr

        def output_equals(value, *args):

            out = self.runbzr(['inventory'] + list(args), backtick=True)

            self.assertEquals(out, value)

        bzr('init')

        open('a', 'wb').write('hello\n')

        os.mkdir('b')

        bzr('add a b')

        bzr('commit -m add')

        output_equals('a\n', '--kind', 'file')

        output_equals('b\n', '--kind', 'directory')        

    def test_ls(self):

        """Test the abilities of 'bzr ls'"""

        bzr = self.runbzr

        def bzrout(*args, **kwargs):

            kwargs['backtick'] = True

            return self.runbzr(*args, **kwargs)

        def ls_equals(value, *args):

            out = self.runbzr(['ls'] + list(args), backtick=True)

            self.assertEquals(out, value)

        bzr('init')

        open('a', 'wb').write('hello\n')

        # Can't supply both

        bzr('ls --verbose --null', retcode=3)

        ls_equals('a\n')

        ls_equals('?        a\n', '--verbose')

        ls_equals('a\n', '--unknown')

        ls_equals('', '--ignored')

        ls_equals('', '--versioned')

        ls_equals('a\n', '--unknown', '--ignored', '--versioned')

        ls_equals('', '--ignored', '--versioned')

        ls_equals('a\0', '--null')

        bzr('add a')

        ls_equals('V        a\n', '--verbose')

        bzr('commit -m add')

        os.mkdir('subdir')

        ls_equals('V        a\n'

                  '?        subdir/\n'

                  , '--verbose')

        open('subdir/b', 'wb').write('b\n')

        bzr('add')

        ls_equals('V        a\n'

                  'V        subdir/\n'

                  'V        subdir/b\n'

                  , '--verbose')

        bzr('commit -m subdir')

        ls_equals('a\n'

                  'subdir\n'

                  , '--non-recursive')

        ls_equals('V        a\n'

                  'V        subdir/\n'

                  , '--verbose', '--non-recursive')

        # Check what happens in a sub-directory

        os.chdir('subdir')

        ls_equals('b\n')

        ls_equals('b\0'

                  , '--null')

        ls_equals('a\n'

                  'subdir\n'

                  'subdir/b\n'

                  , '--from-root')

        ls_equals('a\0'

                  'subdir\0'

                  'subdir/b\0'

                  , '--from-root', '--null')

        ls_equals('a\n'

                  'subdir\n'

                  , '--from-root', '--non-recursive')

        os.chdir('..')

        # Check what happens when we supply a specific revision

        ls_equals('a\n', '--revision', '1')

        ls_equals('V        a\n'

                  , '--verbose', '--revision', '1')

        os.chdir('subdir')

        ls_equals('', '--revision', '1')

        # Now try to do ignored files.

        os.chdir('..')

        open('blah.py', 'wb').write('unknown\n')

        open('blah.pyo', 'wb').write('ignored\n')

        ls_equals('a\n'

                  'blah.py\n'

                  'blah.pyo\n'

                  'subdir\n'

                  'subdir/b\n')

        ls_equals('V        a\n'

                  '?        blah.py\n'

                  'I        blah.pyo\n'

                  'V        subdir/\n'

                  'V        subdir/b\n'

                  , '--verbose')

        ls_equals('blah.pyo\n'

                  , '--ignored')

        ls_equals('blah.py\n'

                  , '--unknown')

        ls_equals('a\n'

                  'subdir\n'

                  'subdir/b\n'

                  , '--versioned')

    def test_cat(self):

        self.runbzr('init')

        file("myfile", "wb").write("My contents\n")

        self.runbzr('add')

        self.runbzr('commit -m myfile')

        self.run_bzr_captured('cat -r 1 myfile'.split(' '))

    def test_pull_verbose(self):

        """Pull changes from one branch to another and watch the output."""

        os.mkdir('a')

        os.chdir('a')

        bzr = self.runbzr

        self.example_branch()

        os.chdir('..')

        bzr('branch a b')

        os.chdir('b')

        open('b', 'wb').write('else\n')

        bzr('add b')

        bzr(['commit', '-m', 'added b'])

        os.chdir('../a')

        out = bzr('pull --verbose ../b', backtick=True)

        self.failIfEqual(out.find('Added Revisions:'), -1)

        self.failIfEqual(out.find('message:\n  added b'), -1)

        self.failIfEqual(out.find('added b'), -1)

        # Check that --overwrite --verbose prints out the removed entries

        bzr('commit -m foo --unchanged')

        os.chdir('../b')

        bzr('commit -m baz --unchanged')

        bzr('pull ../a', retcode=3)

        out = bzr('pull --overwrite --verbose ../a', backtick=1)

        remove_loc = out.find('Removed Revisions:')

        self.failIfEqual(remove_loc, -1)

        added_loc = out.find('Added Revisions:')

        self.failIfEqual(added_loc, -1)

        removed_message = out.find('message:\n  baz')

        self.failIfEqual(removed_message, -1)

        self.failUnless(remove_loc < removed_message < added_loc)

        added_message = out.find('message:\n  foo')

        self.failIfEqual(added_message, -1)

        self.failUnless(added_loc < added_message)

    def test_locations(self):

        """Using and remembering different locations"""

        os.mkdir('a')

        os.chdir('a')

        self.runbzr('init')

        self.runbzr('commit -m unchanged --unchanged')

        self.runbzr('pull', retcode=3)

        self.runbzr('merge', retcode=3)

        self.runbzr('branch . ../b')

        os.chdir('../b')

        self.runbzr('pull')

        self.runbzr('branch . ../c')

        self.runbzr('pull ../c')

        self.runbzr('merge')

        os.chdir('../a')

        self.runbzr('pull ../b')

        self.runbzr('pull')

        self.runbzr('pull ../c')

        self.runbzr('branch ../c ../d')

        rmtree('../c')

        self.runbzr('pull')

        os.chdir('../b')

        self.runbzr('pull')

        os.chdir('../d')

        self.runbzr('pull', retcode=3)

        self.runbzr('pull ../a --remember')

        self.runbzr('pull')

    def test_unknown_command(self):

        """Handling of unknown command."""

        out, err = self.run_bzr_captured(['fluffy-badger'],

                                         retcode=3)

        self.assertEquals(out, '')

        err.index('unknown command')

    def create_conflicts(self):

        """Create a conflicted tree"""

        os.mkdir('base')

        os.chdir('base')

        file('hello', 'wb').write("hi world")

        file('answer', 'wb').write("42")

        self.runbzr('init')

        self.runbzr('add')

        self.runbzr('commit -m base')

        self.runbzr('branch . ../other')

        self.runbzr('branch . ../this')

        os.chdir('../other')

        file('hello', 'wb').write("Hello.")

        file('answer', 'wb').write("Is anyone there?")

        self.runbzr('commit -m other')

        os.chdir('../this')

        file('hello', 'wb').write("Hello, world")

        self.runbzr('mv answer question')

        file('question', 'wb').write("What do you get when you multiply six"

                                   "times nine?")

        self.runbzr('commit -m this')

    def test_status(self):

        os.mkdir('branch1')

        os.chdir('branch1')

        self.runbzr('init')

        self.runbzr('commit --unchanged --message f')

        self.runbzr('branch . ../branch2')

        self.runbzr('branch . ../branch3')

        self.runbzr('commit --unchanged --message peter')

        os.chdir('../branch2')

        self.runbzr('merge ../branch1')

        self.runbzr('commit --unchanged --message pumpkin')

        os.chdir('../branch3')

        self.runbzr('merge ../branch2')

        message = self.capture('status')

    def test_conflicts(self):

        """Handling of merge conflicts"""

        self.create_conflicts()

        self.runbzr('merge ../other --show-base', retcode=1)

        conflict_text = file('hello').read()

        self.assert_('<<<<<<<' in conflict_text)

        self.assert_('>>>>>>>' in conflict_text)

        self.assert_('=======' in conflict_text)

        self.assert_('|||||||' in conflict_text)

        self.assert_('hi world' in conflict_text)

        self.runbzr('revert')

        self.runbzr('resolve --all')

        self.runbzr('merge ../other', retcode=1)

        conflict_text = file('hello').read()

        self.assert_('|||||||' not in conflict_text)

        self.assert_('hi world' not in conflict_text)

        result = self.runbzr('conflicts', backtick=1)

        self.assertEquals(result, "Text conflict in hello\nText conflict in"

                                  " question\n")

        result = self.runbzr('status', backtick=1)

        self.assert_("conflicts:\n  Text conflict in hello\n"

                     "  Text conflict in question\n" in result, result)

        self.runbzr('resolve hello')

        result = self.runbzr('conflicts', backtick=1)

        self.assertEquals(result, "Text conflict in question\n")

        self.runbzr('commit -m conflicts', retcode=3)

        self.runbzr('resolve --all')

        result = self.runbzr('conflicts', backtick=1)

        self.runbzr('commit -m conflicts')

        self.assertEquals(result, "")

    def test_push(self):

        # create a source branch

        os.mkdir('my-branch')

        os.chdir('my-branch')

        self.example_branch()

        # with no push target, fail

        self.runbzr('push', retcode=3)

        # with an explicit target work

        self.runbzr('push ../output-branch')

        # with an implicit target work

        self.runbzr('push')

        # nothing missing

        self.runbzr('missing ../output-branch')

        # advance this branch

        self.runbzr('commit --unchanged -m unchanged')

        os.chdir('../output-branch')

        # There is no longer a difference as long as we have

        # access to the working tree

        self.runbzr('diff')

        # But we should be missing a revision

        self.runbzr('missing ../my-branch', retcode=1)

        # diverge the branches

        self.runbzr('commit --unchanged -m unchanged')

        os.chdir('../my-branch')

        # cannot push now

        self.runbzr('push', retcode=3)

        # and there are difference

        self.runbzr('missing ../output-branch', retcode=1)

        self.runbzr('missing --verbose ../output-branch', retcode=1)

        # but we can force a push

        self.runbzr('push --overwrite')

        # nothing missing

        self.runbzr('missing ../output-branch')

        # pushing to a new dir with no parent should fail

        self.runbzr('push ../missing/new-branch', retcode=3)

        # unless we provide --create-prefix

        self.runbzr('push --create-prefix ../missing/new-branch')

        # nothing missing

        self.runbzr('missing ../missing/new-branch')

    def test_external_command(self):

        """Test that external commands can be run by setting the path

        """

        # We don't at present run bzr in a subprocess for blackbox tests, and so 

        # don't really capture stdout, only the internal python stream.

        # Therefore we don't use a subcommand that produces any output or does

        # anything -- we just check that it can be run successfully.  

        cmd_name = 'test-command'

        if sys.platform == 'win32':

            cmd_name += '.bat'

        oldpath = os.environ.get('BZRPATH', None)

        bzr = self.capture

        try:

            if os.environ.has_key('BZRPATH'):

                del os.environ['BZRPATH']

            f = file(cmd_name, 'wb')

            if sys.platform == 'win32':

                f.write('@echo off\n')

            else:

                f.write('#!/bin/sh\n')

            # f.write('echo Hello from test-command')

            f.close()

            os.chmod(cmd_name, 0755)

            # It should not find the command in the local 

            # directory by default, since it is not in my path

            bzr(cmd_name, retcode=3)

            # Now put it into my path

            os.environ['BZRPATH'] = '.'

            bzr(cmd_name)

            # Make sure empty path elements are ignored

            os.environ['BZRPATH'] = os.pathsep

            bzr(cmd_name, retcode=3)

        finally:

            if oldpath:

                os.environ['BZRPATH'] = oldpath

def listdir_sorted(dir):

    L = os.listdir(dir)

    L.sort()

    return L

class OldTests(ExternalBase):

    """old tests moved from ./testbzr."""

    def test_bzr(self):

        from os import chdir, mkdir

        from os.path import exists

        runbzr = self.runbzr

        capture = self.capture

        progress = self.log

        progress("basic branch creation")

        mkdir('branch1')

        chdir('branch1')

        runbzr('init')

        self.assertEquals(capture('root').rstrip(),

                          pathjoin(self.test_dir, 'branch1'))

        progress("status of new file")

        f = file('test.txt', 'wt')

        f.write('hello world!\n')

        f.close()

        self.assertEquals(capture('unknowns'), 'test.txt\n')

        out = capture("status")

        self.assertEquals(out, 'unknown:\n  test.txt\n')

        f = file('test2.txt', 'wt')

        f.write('goodbye cruel world...\n')

        f.close()

        out = capture("status test.txt")