Merge lp:~justas.sadzevicius/schooltool/schooltool.section_spanning into lp:~schooltool-owners/schooltool/schooltool

[Justas Sadzevičius]

[Justas Sadzevičius (justas.sadzevicius)]

Section spanning core

[lp:~justas.sadzevicius/schooltool/schooltool.section_spanning]

2462. By Justas Sadzevičius on 2009-04-28

Simple section cross-term copying interface.

=== modified file 'src/schooltool/course/configure.zcml'
--- src/schooltool/course/configure.zcml	2008-10-13 13:14:27 +0000
+++ src/schooltool/course/configure.zcml	2009-03-21 12:52:42 +0000
@@ -178,6 +178,10 @@
   <adapter
       factory=".section.PersonInstructorAdapter" />
 
+  <!-- Validators -->
+  <adapter factory=".section.SectionLinkContinuinityValidationSubscriber"
+           name="validate_term_continuinity"/>
+
   <!-- Views -->
   <include package=".browser" />
 

=== modified file 'src/schooltool/course/interfaces.py'
--- src/schooltool/course/interfaces.py	2008-09-04 12:25:48 +0000
+++ src/schooltool/course/interfaces.py	2009-03-21 12:52:42 +0000
@@ -97,6 +97,15 @@
     size = zope.interface.Attribute(
         """The number of member students in the section.""")
 
+    previous = zope.interface.Attribute(
+        """The previous section.""")
+
+    next = zope.interface.Attribute(
+        """The next section.""")
+
+    linked_sections = zope.interface.Attribute(
+        """Chain of sections linked by previous/next with this one.""")
+
 
 class ISectionContainer(container.interfaces.IContainer):
     """A container for Sections."""

=== modified file 'src/schooltool/course/section.py'
--- src/schooltool/course/section.py	2008-10-08 10:52:54 +0000
+++ src/schooltool/course/section.py	2009-03-22 13:06:04 +0000
@@ -22,13 +22,17 @@
 $Id$
 """
 from persistent import Persistent
+import rwproperty
 import zope.interface
 
+from zope.event import notify
 from zope.annotation.interfaces import IAttributeAnnotatable
-from zope.app.container.interfaces import IObjectRemovedEvent
+from zope.app.container.interfaces import IObjectRemovedEvent, INameChooser
 from zope.app.container import btree, contained
 from zope.component import adapts
 from zope.interface import implements
+from zope.proxy import sameProxiedObjects
+from zope.security.proxy import removeSecurityProxy
 
 from schooltool.relationship import RelationshipProperty
 from schooltool.app import membership
@@ -41,7 +45,9 @@
 from schooltool.common import SchoolToolMessage as _
 from schooltool.app import relationships
 from schooltool.course import interfaces, booking
+from schooltool.schoolyear.subscriber import EventAdapterSubscriber
 from schooltool.schoolyear.subscriber import ObjectEventAdapterSubscriber
+from schooltool.schoolyear.interfaces import ISubscriber
 from schooltool.schoolyear.interfaces import ISchoolYear
 from schooltool.securitypolicy.crowds import Crowd, AggregateCrowd
 from schooltool.course.interfaces import ICourseContainer
@@ -51,6 +57,16 @@
 from schooltool.course.interfaces import ILearner, IInstructor
 
 
+class InvalidSectionLinkException(Exception):
+    pass
+
+
+class SectionBeforeLinkingEvent(object):
+    def __init__(self, first, second):
+        self.first = first
+        self.second = second
+
+
 class Section(Persistent, contained.Contained):
 
     zope.interface.implements(interfaces.ISectionContained,
@@ -58,6 +74,9 @@
 
     _location = None
 
+    _previous = None
+    _next = None
+
     def __init__(self, title="Section", description=None, schedule=None):
         self.title = title
         self.description = description
@@ -79,6 +98,89 @@
                 size = size + len(member.members)
         return size
 
+    def _unlinkRangeTo(self, other):
+        """Unlink sections between self and the other in self.linked_sections."""
+        linked = self.linked_sections
+        if other not in linked or self is other:
+            return
+        idx_first, idx_last = sorted([linked.index(self), linked.index(other)])
+        linked[idx_first]._next = None
+        for section in linked[idx_first+1:idx_last]:
+            section._previous = None
+            section._next = None
+        linked[idx_last]._previous = None
+
+    @rwproperty.getproperty
+    def previous(self):
+        return self._previous
+
+    @rwproperty.setproperty
+    def previous(self, new):
+        new = removeSecurityProxy(new)
+        if new is self._previous:
+            return
+        if new is self:
+            raise InvalidSectionLinkException(
+                _('Cannot assign section as previous to itself'))
+
+        notify(SectionBeforeLinkingEvent(new, self))
+
+        if new is not None:
+            self._unlinkRangeTo(new)
+
+        old_prev = self._previous
+        self._previous = None
+        if old_prev is not None:
+            old_prev.next = None
+        self._previous = new
+
+        if new is not None:
+            new.next = self
+
+    @rwproperty.getproperty
+    def next(self):
+        return self._next
+
+    @rwproperty.setproperty
+    def next(self, new):
+        new = removeSecurityProxy(new)
+        if new is self._next:
+            return
+        if new is self:
+            raise InvalidSectionLinkException(
+                _('Cannot assign section as next to itself'))
+
+        notify(SectionBeforeLinkingEvent(self, new))
+
+        if new is not None:
+            self._unlinkRangeTo(new)
+
+        old_next = self._next
+        self._next = None
+        if old_next is not None:
+            old_next.previous = None
+        self._next = new
+
+        if new is not None:
+            new.previous = self
+
+    @property
+    def linked_sections(self):
+        sections = [self]
+
+        pit = self.previous
+        while pit:
+            sections.insert(0, pit)
+            pit = pit.previous
+
+        nit = self.next
+        while nit:
+            sections.append(nit)
+            nit = nit.next
+
+        return sections
+
+
     instructors = RelationshipProperty(relationships.URIInstruction,
                                        relationships.URISection,
                                        relationships.URIInstructor)
@@ -266,3 +368,46 @@
         section_container = ISectionContainer(self.object)
         for section_id in list(section_container.keys()):
             del section_container[section_id]
+
+
+class SectionLinkContinuinityValidationSubscriber(EventAdapterSubscriber):
+    adapts(SectionBeforeLinkingEvent)
+    implements(ISubscriber)
+
+    def __call__(self):
+        if (self.event.first is None or
+            self.event.second is None):
+            return # unlinking sections
+
+        first_term = ITerm(self.event.first)
+        second_term = ITerm(self.event.second)
+        if sameProxiedObjects(first_term, second_term):
+            raise InvalidSectionLinkException(
+                _("Cannot link sections in same term"))
+
+        if first_term.first > second_term.first:
+            raise InvalidSectionLinkException(
+                _("Sections are not in subsequent terms"))
+
+        if not sameProxiedObjects(ISchoolYear(first_term),
+                                  ISchoolYear(second_term)):
+            raise InvalidSectionLinkException(
+                _("Cannot link sections in different school years"))
+
+
+def copySection(section, target_term):
+    """Create a copy of a section in a desired term."""
+    section_copy = Section(section.title, section.description)
+    sections = ISectionContainer(target_term)
+    name = section.__name__
+    if name in sections:
+        name = INameChooser(sections).chooseName(name, section_copy)
+    sections[name] = section_copy
+    for course in section.courses:
+        section_copy.courses.add(course)
+    for instructor in section.instructors:
+        section_copy.instructors.add(instructor)
+    for member in section.members:
+        section_copy.members.add(member)
+    return section_copy
+

=== modified file 'src/schooltool/course/tests/test_course.py'
--- src/schooltool/course/tests/test_course.py	2007-07-14 15:18:18 +0000
+++ src/schooltool/course/tests/test_course.py	2009-03-21 12:52:42 +0000
@@ -25,6 +25,8 @@
 from zope.testing import doctest
 from zope.interface.verify import verifyObject
 
+from schooltool.relationship.tests import setUp, tearDown
+
 
 def doctest_CourseContainer():
     r"""Schooltool toplevel container for Courses.
@@ -46,6 +48,7 @@
         Traceback (most recent call last):
           ...
         InvalidItemType: ...
+
     """
 
 
@@ -74,9 +77,7 @@
 
     To test the relationship we need to do some setup:
 
-        >>> from schooltool.relationship.tests import setUp, tearDown
         >>> from schooltool.app.relationships import enforceCourseSectionConstraint
-        >>> setUp()
         >>> import zope.event
         >>> old_subscribers = zope.event.subscribers[:]
         >>> zope.event.subscribers.append(enforceCourseSectionConstraint)
@@ -131,16 +132,13 @@
     That's it:
 
         >>> zope.event.subscribers[:] = old_subscribers
-        >>> tearDown()
+
     """
 
 
 def doctest_Section():
     r"""Tests for course section groups.
 
-        >>> from schooltool.relationship.tests import setUp, tearDown
-        >>> setUp()
-
         >>> from schooltool.course.section import Section
         >>> section = Section(title="section 1", description="advanced")
         >>> from schooltool.course.interfaces import ISection
@@ -237,9 +235,216 @@
         US History
         English
 
-    We're done:
-
-        >>> tearDown()
+    """
+
+
+def doctest_Section_linking():
+    r"""Tests for course section linking properties (previous, next and
+    linked_sections)
+
+    The purpose of this test is to check that:
+    * sections can be linked via Section.previous and Section.next.
+    * Section.linked_sections return sections linked with the Section
+      in a correct order.
+    * it is impossible to create linking loops.
+
+        >>> from schooltool.course.section import Section
+
+        >>> def section_link_str(s):
+        ...     return '%s <- %s -> %s' % (
+        ...         not s.previous and 'None' or s.previous.title,
+        ...         s.title,
+        ...         not s.next and 'None' or s.next.title)
+
+        >>> def print_sections(sections):
+        ...     '''Print prev and next links for all sections in section_list'''
+        ...     for s in sections:
+        ...         print section_link_str(s)
+
+        >>> def print_linked(section_list):
+        ...     '''Print linked sections for all sections in section_list'''
+        ...     for section in section_list:
+        ...         linked_str = ', '.join(
+        ...             [s.title for s in section.linked_sections])
+        ...         print section.title, 'spans:', linked_str
+
+    Create some sections.
+
+        >>> sections = [Section('Sec0'), Section('Sec1'), Section('Sec2')]
+
+    By default sections are not linked.
+
+        >>> print_sections(sections)
+        None <- Sec0 -> None
+        None <- Sec1 -> None
+        None <- Sec2 -> None
+
+    And each section spans only itself.
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec0
+        Sec1 spans: Sec1
+        Sec2 spans: Sec2
+
+    Assign s0 as previous section to s1.  s0 'next' section is also updated.
+    A list of linked sections updated for s0 and s1.
+
+        >>> sections[1].previous = sections[0]
+
+        >>> print_sections(sections)
+        None <- Sec0 -> Sec1
+        Sec0 <- Sec1 -> None
+        None <- Sec2 -> None
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec0, Sec1
+        Sec1 spans: Sec0, Sec1
+        Sec2 spans: Sec2
+
+    Assign s2 as next section to s1.
+
+        >>> sections[1].next = sections[2]
+
+        >>> print_sections(sections)
+        None <- Sec0 -> Sec1
+        Sec0 <- Sec1 -> Sec2
+        Sec1 <- Sec2 -> None
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec0, Sec1, Sec2
+        Sec1 spans: Sec0, Sec1, Sec2
+        Sec2 spans: Sec0, Sec1, Sec2
+
+    Let's test section unlinking...
+
+        >>> sections[1].previous = None
+        >>> print_sections(sections)
+        None <- Sec0 -> None
+        None <- Sec1 -> Sec2
+        Sec1 <- Sec2 -> None
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec0
+        Sec1 spans: Sec1, Sec2
+        Sec2 spans: Sec1, Sec2
+
+        >>> sections[2].previous = None
+        >>> print_sections(sections)
+        None <- Sec0 -> None
+        None <- Sec1 -> None
+        None <- Sec2 -> None
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec0
+        Sec1 spans: Sec1
+        Sec2 spans: Sec2
+
+    And now some extreme cases.  Try the section as next/prev to itself.
+
+        >>> sections[0].previous = sections[0]
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException: Cannot assign section as previous to itself
+
+        >>> sections[0].next = sections[0]
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException: Cannot assign section as next to itself
+
+    Create a long list of linked sections.
+
+        >>> sections = [Section('Sec0')]
+        >>> for n in range(5):
+        ...     new_sec = Section('Sec%d' % (n+1))
+        ...     new_sec.previous = sections[-1]
+        ...     sections.append(new_sec)
+
+        >>> print_sections(sections)
+        None <- Sec0 -> Sec1
+        Sec0 <- Sec1 -> Sec2
+        Sec1 <- Sec2 -> Sec3
+        Sec2 <- Sec3 -> Sec4
+        Sec3 <- Sec4 -> Sec5
+        Sec4 <- Sec5 -> None
+
+    Try to introduce a loop by assigning a previous section.
+
+        >>> sections[4].previous = sections[1]
+
+    Note that sections 2 and 3 are removed from the linked list thus avoiding
+    the loop.
+
+        >>> print_sections(sections)
+        None <- Sec0 -> Sec1
+        Sec0 <- Sec1 -> Sec4
+        None <- Sec2 -> None
+        None <- Sec3 -> None
+        Sec1 <- Sec4 -> Sec5
+        Sec4 <- Sec5 -> None
+
+        >>> [s.title for s in sections[0].linked_sections]
+        ['Sec0', 'Sec1', 'Sec4', 'Sec5']
+
+    Let's reubild the list of 5 linked sections.
+
+        >>> sections[4].previous = sections[3]
+        >>> sections[3].previous = sections[2]
+        >>> sections[2].previous = sections[1]
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec1 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec2 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec3 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec4 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec5 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+
+
+    Try to introduce a loop by assigning a next section.
+
+        >>> sections[1].next = sections[4]
+
+    Note that sections 2 and 3 are removed from the linked list thus avoiding
+    the loop again.
+
+        >>> print_sections(sections)
+        None <- Sec0 -> Sec1
+        Sec0 <- Sec1 -> Sec4
+        None <- Sec2 -> None
+        None <- Sec3 -> None
+        Sec1 <- Sec4 -> Sec5
+        Sec4 <- Sec5 -> None
+
+        >>> [s.title for s in sections[0].linked_sections]
+        ['Sec0', 'Sec1', 'Sec4', 'Sec5']
+
+    Let's reubild the list of 5 linked sections.
+
+        >>> sections[3].next = sections[4]
+        >>> sections[2].next = sections[3]
+        >>> sections[1].next = sections[2]
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec1 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec2 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec3 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec4 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+        Sec5 spans: Sec0, Sec1, Sec2, Sec3, Sec4, Sec5
+
+    And try to introduce another loop.
+
+        >>> sections[0].previous = sections[3]
+
+    Sections between Sec0 and Sec3 were unlinked to avoid the loop.
+
+        >>> print_linked(sections)
+        Sec0 spans: Sec3, Sec0
+        Sec1 spans: Sec1
+        Sec2 spans: Sec2
+        Sec3 spans: Sec3, Sec0
+        Sec4 spans: Sec4, Sec5
+        Sec5 spans: Sec4, Sec5
 
     """
 
@@ -247,9 +452,6 @@
 def doctest_PersonInstructorCrowd():
     """Unit test for the PersonInstructorCrowd
 
-        >>> from schooltool.relationship.tests import setUp, tearDown
-        >>> setUp()
-
     We'll need a section, a group, and a couple of persons:
 
         >>> from schooltool.course.section import Section
@@ -284,18 +486,12 @@
         >>> PersonInstructorsCrowd(p2).contains(p1)
         False
 
-    Cleanup.
-
-        >>> tearDown()
     """
 
 
 def doctest_PersonLearnerAdapter(self):
     """Tests for PersonLearnerAdapter.
 
-        >>> from schooltool.relationship.tests import setUp, tearDown
-        >>> setUp()
-
     We'll need a person, a group, and a couple of sections:
 
         >>> from schooltool.course.section import Section
@@ -320,16 +516,14 @@
         >>> [section.title for section in learner.sections()]
         ['section 1', 'section 2']
 
-    Cleanup.
-
-        >>> tearDown()
     """
 
 
 def test_suite():
-    return unittest.TestSuite([
-                doctest.DocTestSuite(optionflags=doctest.ELLIPSIS),
-           ])
+    optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
+    suite = doctest.DocTestSuite(optionflags=optionflags,
+                                 setUp=setUp, tearDown=tearDown)
+    return suite
 
 
 if __name__ == '__main__':

=== added file 'src/schooltool/course/tests/test_subscribers.py'
--- src/schooltool/course/tests/test_subscribers.py	1970-01-01 00:00:00 +0000
+++ src/schooltool/course/tests/test_subscribers.py	2009-03-22 13:06:04 +0000
@@ -0,0 +1,262 @@
+#
+# SchoolTool - common information systems platform for school administration
+# Copyright (c) 2005 Shuttleworth Foundation
+#
+# 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
+#
+"""
+Unit tests for course and section subscriber validation.
+
+$Id$
+"""
+
+import unittest
+from datetime import date, timedelta
+from zope.testing import doctest
+
+from schooltool.schoolyear.testing import (setUp, tearDown,
+                                           provideStubUtility,
+                                           provideStubAdapter)
+from schooltool.schoolyear.ftesting import schoolyear_functional_layer
+from schooltool.app.interfaces import ISchoolToolApplication
+from schooltool.schoolyear.interfaces import ISchoolYearContainer
+from schooltool.schoolyear.schoolyear import SchoolYear
+from schooltool.term.interfaces import ITerm
+from schooltool.term.term import Term
+from schooltool.course.interfaces import ISectionContainer
+from schooltool.course.section import Section
+
+
+def setUpSchoolYear(year=2000):
+    year_container = ISchoolYearContainer(ISchoolToolApplication(None))
+    sy = year_container[str(year)] = SchoolYear(
+        str(year), date(year, 1, 1), date(year+1, 1, 1) - timedelta(1))
+    return sy
+
+
+def setUpTerms(schoolyear, term_count=3):
+    term_delta = timedelta(
+        ((schoolyear.last - schoolyear.first) / term_count).days)
+    start_date = schoolyear.first
+    for n in range(term_count):
+        finish_date = start_date + term_delta - timedelta(1)
+        schoolyear['Term%d' % (n+1)] = Term(
+            'Term %d' % (n+1), start_date, finish_date)
+        start_date = finish_date + timedelta(1)
+
+
+def setUpSections(term_list, sections_per_term=1):
+    for term in term_list:
+        sections = ISectionContainer(term)
+        for n in range(sections_per_term):
+            name = 'Sec%d'%(n+1)
+            sections[name] = Section(name)
+
+
+def doctest_Section_linking_terms():
+    r"""Tests for section linking term continuinity validations.
+
+    Set up a school year with three terms, each containing two sections.
+
+        >>> year = setUpSchoolYear(2000)
+        >>> setUpTerms(year, 3)
+        >>> setUpSections(year.values(), sections_per_term=2)
+
+    Let's make Sec1 span the three terms.
+
+        >>> s1_t1 = ISectionContainer(year['Term1'])['Sec1']
+        >>> s1_t2 = ISectionContainer(year['Term2'])['Sec1']
+        >>> s1_t3 = ISectionContainer(year['Term3'])['Sec1']
+
+        >>> s1_t2.previous = s1_t1
+        >>> s1_t2.next = s1_t3
+
+        >>> for s in s1_t2.linked_sections:
+        ...     print '%s, %s' % (ITerm(s).title, s.title)
+        Term 1, Sec1
+        Term 2, Sec1
+        Term 3, Sec1
+
+    We cannot link a section to another section in the same term.
+
+        >>> s2_t1 = ISectionContainer(year['Term1'])['Sec2']
+        >>> s2_t2 = ISectionContainer(year['Term2'])['Sec2']
+        >>> s2_t3 = ISectionContainer(year['Term3'])['Sec2']
+
+        >>> s2_t2.next = s1_t2
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException: Cannot link sections in same term
+
+        >>> s2_t2.previous = s1_t2
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException: Cannot link sections in same term
+
+    Cannot set previous section in the future.
+
+        >>> s2_t2.previous = s1_t3
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException: Sections are not in subsequent terms
+
+    Or set next section in the past.
+
+        >>> s2_t2.next = s1_t1
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException: Sections are not in subsequent terms
+
+    Notice that though we tried to link Sec2 with Sec1, we didn't change it's
+    linked_sections, becouse all our assigments were invalid.
+
+        >>> for s in s1_t2.linked_sections:
+        ...     print '%s, %s' % (ITerm(s).title, s.title)
+        Term 1, Sec1
+        Term 2, Sec1
+        Term 3, Sec1
+
+    Let's test an unusual case: continue Section 1 from Term 1 as Section 2
+    in the last term.
+
+        >>> s2_t3.previous = s1_t1
+
+    Section 2 in third term now continues Section 1.
+
+        >>> for s in s1_t1.linked_sections:
+        ...     print '%s, %s' % (ITerm(s).title, s.title)
+        Term 1, Sec1
+        Term 3, Sec2
+
+    Section 1 now spans only terms 2 and 3.
+
+        >>> for s in s1_t2.linked_sections:
+        ...     print '%s, %s' % (ITerm(s).title, s.title)
+        Term 2, Sec1
+        Term 3, Sec1
+
+    """
+
+
+def doctest_Section_linking_schoolyears():
+    r"""Tests for section linking SchoolYear validations.
+
+    Set up a school year with three terms, each containing two sections.
+
+        >>> def setUpYearWithSection(year):
+        ...     year = setUpSchoolYear(year)
+        ...     setUpTerms(year, 1)
+        ...     setUpSections(year.values(), sections_per_term=1)
+        ...     return year
+
+        >>> year0 = setUpYearWithSection(2000)
+        >>> year1 = setUpYearWithSection(2001)
+        >>> year2 = setUpYearWithSection(2002)
+
+        >>> sec_year_0 = ISectionContainer(year0['Term1'])['Sec1']
+        >>> sec_year_1 = ISectionContainer(year1['Term1'])['Sec1']
+        >>> sec_year_2 = ISectionContainer(year2['Term1'])['Sec1']
+
+    We cannot link sections in the different school years.
+
+        >>> sec_year_1.previous = sec_year_0
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException:
+        Cannot link sections in different school years
+
+        >>> sec_year_1.next = sec_year_2
+        Traceback (most recent call last):
+        ...
+        InvalidSectionLinkException:
+        Cannot link sections in different school years
+
+    """
+
+
+def doctest_copySection():
+    r"""Test for copySection.
+
+        >>> from schooltool.course.section import Section
+        >>> from schooltool.course.course import Course
+        >>> from schooltool.person.person import Person
+
+    Create a section with a course, instructor and several members.
+
+        >>> year = setUpSchoolYear(2000)
+        >>> setUpTerms(year, 2)
+
+        >>> section = Section('English A')
+        >>> section.instructors.add(Person('teacher', 'Mr. Jones'))
+        >>> section.members.add(Person('first','First'))
+        >>> section.members.add(Person('second','Second'))
+        >>> section.members.add(Person('third','Third'))
+        >>> section.courses.add(Course(title="English"))
+        >>> ISectionContainer(year['Term1'])['Sec1'] = section
+
+    Let's copy it to another term.
+
+        >>> from schooltool.course.section import copySection
+
+        >>> new_section = copySection(section, year['Term2'])
+
+    Sectoin's copy was created.
+
+        >>> new_section is not section
+        True
+
+    Sec1 was available as section id in the new term, so it was preserved.
+
+        >>> print new_section.__name__
+        Sec1
+
+    Courses, instructors and members were copied.
+
+        >>> for course in new_section.courses:
+        ...     print course.title
+        English
+
+        >>> for person in new_section.instructors:
+        ...     print person.title
+        Mr. Jones
+
+        >>> for person in new_section.members:
+        ...     print person.title
+        First
+        Second
+        Third
+
+    If original section's __name__ is already present in the target term, an
+    alternative is chosen.
+
+        >>> other_section = copySection(section, year['Term2'])
+        >>> print other_section.__name__
+        1
+
+    """
+
+
+def test_suite():
+    optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
+    suite = doctest.DocTestSuite(optionflags=optionflags,
+                                 extraglobs={'provideAdapter': provideStubAdapter,
+                                             'provideUtility': provideStubUtility},
+                                 setUp=setUp, tearDown=tearDown)
+    suite.layer = schoolyear_functional_layer
+    return suite
+
+
+if __name__ == '__main__':
+    unittest.main(defaultTest='test_suite')

=== modified file 'src/schooltool/relationship/tests/__init__.py'
--- src/schooltool/relationship/tests/__init__.py	2006-05-05 18:03:22 +0000
+++ src/schooltool/relationship/tests/__init__.py	2009-03-21 12:52:42 +0000
@@ -60,7 +60,7 @@
         return cmp(self.uri, other.uri)
 
 
-def setUp():
+def setUp(test=None):
     """Set up for schooltool.relationship doctests.
 
     Calls Zope's placelessSetUp, sets up annotations and relationships.
@@ -70,7 +70,7 @@
     setUpRelationships()
 
 
-def tearDown():
+def tearDown(test=None):
     """Tear down for schooltool.relationshp doctests."""
     setup.placelessTearDown()