~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2007, 2009, 2010 Canonical Ltd

#

# 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

"""Tests for OS level locks."""

from bzrlib import (

    errors,

    osutils,

    )

from bzrlib.tests import (

    features,

    )

from bzrlib.tests.per_lock import TestCaseWithLock

class TestLock(TestCaseWithLock):

    def setUp(self):

        super(TestLock, self).setUp()

        self.build_tree(['a-file'])

    def test_read_lock(self):

        """Smoke test for read locks."""

        a_lock = self.read_lock('a-file')

        self.addCleanup(a_lock.unlock)

        # The lock file should be opened for reading

        txt = a_lock.f.read()

        self.assertEqual('contents of a-file\n', txt)

    def test_create_if_needed_read(self):

        """We will create the file if it doesn't exist yet."""

        a_lock = self.read_lock('other-file')

        self.addCleanup(a_lock.unlock)

        txt = a_lock.f.read()

        self.assertEqual('', txt)

    def test_create_if_needed_write(self):

        """We will create the file if it doesn't exist yet."""

        a_lock = self.write_lock('other-file')

        self.addCleanup(a_lock.unlock)

        txt = a_lock.f.read()

        self.assertEqual('', txt)

        a_lock.f.seek(0)

        a_lock.f.write('foo\n')

        a_lock.f.seek(0)

        txt = a_lock.f.read()

        self.assertEqual('foo\n', txt)

    def test_readonly_file(self):

        """If the file is readonly, we can take a read lock.

        But we shouldn't be able to take a write lock.

        """

        self.requireFeature(features.not_running_as_root)

        osutils.make_readonly('a-file')

        # Make sure the file is read-only (on all platforms)

        self.assertRaises(IOError, open, 'a-file', 'rb+')

        a_lock = self.read_lock('a-file')

        a_lock.unlock()

        self.assertRaises(errors.LockFailed, self.write_lock, 'a-file')

    def test_write_lock(self):

        """Smoke test for write locks."""

        a_lock = self.write_lock('a-file')

        self.addCleanup(a_lock.unlock)

        # You should be able to read and write to the lock file.

        txt = a_lock.f.read()

        self.assertEqual('contents of a-file\n', txt)

        # Win32 requires that you call seek() when switching between a read

        # operation and a write operation.

        a_lock.f.seek(0, 2)

        a_lock.f.write('more content\n')

        a_lock.f.seek(0)

        txt = a_lock.f.read()

        self.assertEqual('contents of a-file\nmore content\n', txt)

    def test_multiple_read_locks(self):

        """You can take out more than one read lock on the same file."""

        a_lock = self.read_lock('a-file')

        self.addCleanup(a_lock.unlock)

        b_lock = self.read_lock('a-file')

        self.addCleanup(b_lock.unlock)

    def test_multiple_write_locks_exclude(self):

        """Taking out more than one write lock should fail."""

        a_lock = self.write_lock('a-file')

        self.addCleanup(a_lock.unlock)

        # Taking out a lock on a locked file should raise LockContention

        self.assertRaises(errors.LockContention, self.write_lock, 'a-file')

    def _disabled_test_read_then_write_excludes(self):

        """If a file is read-locked, taking out a write lock should fail."""

        a_lock = self.read_lock('a-file')

        self.addCleanup(a_lock.unlock)

        # Taking out a lock on a locked file should raise LockContention

        self.assertRaises(errors.LockContention, self.write_lock, 'a-file')

    def test_read_unlock_write(self):

        """Make sure that unlocking allows us to lock write"""

        a_lock = self.read_lock('a-file')

        a_lock.unlock()

        a_lock = self.write_lock('a-file')

        a_lock.unlock()

    # TODO: jam 20070319 fcntl read locks are not currently fully

    #       mutually exclusive with write locks. This will be fixed

    #       in the next release.

    def _disabled_test_write_then_read_excludes(self):

        """If a file is write-locked, taking out a read lock should fail.

        The file is exclusively owned by the write lock, so we shouldn't be

        able to take out a shared read lock.

        """

        a_lock = self.write_lock('a-file')

        self.addCleanup(a_lock.unlock)

        # Taking out a lock on a locked file should raise LockContention

        self.assertRaises(errors.LockContention, self.read_lock, 'a-file')

    # TODO: jam 20070319 fcntl write locks are not currently fully

    #       mutually exclusive with read locks. This will be fixed

    #       in the next release.

    def _disabled_test_write_unlock_read(self):

        """If we have removed the write lock, we can grab a read lock."""

        a_lock = self.write_lock('a-file')

        a_lock.unlock()

        a_lock = self.read_lock('a-file')

        a_lock.unlock()

    def _disabled_test_multiple_read_unlock_write(self):

        """We can only grab a write lock if all read locks are done."""

        a_lock = b_lock = c_lock = None

        try:

            a_lock = self.read_lock('a-file')

            b_lock = self.read_lock('a-file')

            self.assertRaises(errors.LockContention, self.write_lock, 'a-file')

            a_lock.unlock()

            a_lock = None

            self.assertRaises(errors.LockContention, self.write_lock, 'a-file')

            b_lock.unlock()

            b_lock = None

            c_lock = self.write_lock('a-file')

            c_lock.unlock()

            c_lock = None

        finally:

            # Cleanup as needed

            if a_lock is not None:

                a_lock.unlock()

            if b_lock is not None:

                b_lock.unlock()

            if c_lock is not None:

                c_lock.unlock()

class TestLockUnicodePath(TestCaseWithLock):

    _test_needs_features = [features.UnicodeFilenameFeature]

    def test_read_lock(self):

        self.build_tree([u'\u1234'])

        u_lock = self.read_lock(u'\u1234')

        self.addCleanup(u_lock.unlock)

    def test_write_lock(self):

        self.build_tree([u'\u1234'])

        u_lock = self.write_lock(u'\u1234')

        self.addCleanup(u_lock.unlock)