Merge branch 'releases/0.2'

Conflicts:
	oscar/__init__.py
	oscar/apps/basket/abstract_models.py
	oscar/apps/checkout/views.py
	tests/functional/basket_tests.py

README.rst

 allows it to handle a wide range of e-commerce requirements, from large-scale B2C
 sites to complex B2B sites rich in domain-specific business logic.
 
-This README is just a stub - see the following links for more details
-information:
+More information:
 
 * `Official homepage`_ 
-* `Demo site`_ (experimental) 
-* `Documentation`_ on `readthedocs.org`_
+* `Sandbox site`_ (an hourly build of the unstable master branch - it's
+  experimental but feel free to explore and get a feel for the base Oscar
+  install) 
+* `Documentation`_ on the excellent `readthedocs.org`_
 * `Google Group`_ - the mailing list is django-oscar@googlegroups.com
 * `Continuous integration homepage`_ on `travis-ci.org`_
 * `Twitter account for news and updates`_
 .. image:: https://secure.travis-ci.org/tangentlabs/django-oscar.png
 
 .. _`Official homepage`: http://oscarcommerce.com
-.. _`Demo site`: http://sandbox.oscar.tangentlabs.co.uk
+.. _`Sandbox site`: http://sandbox.oscar.tangentlabs.co.uk
 .. _`Documentation`: http://django-oscar.readthedocs.org/en/latest/
 .. _`readthedocs.org`: http://readthedocs.org
 .. _`Continuous integration homepage`: http://travis-ci.org/#!/tangentlabs/django-oscar 
 .. _`Google Group`: https://groups.google.com/forum/?fromgroups#!forum/django-oscar
 
 Oscar was written by `David Winterbottom`_ (`@codeinthehole`_) and is developed
-and maintained by `Tangent Labs`_, a London-based digital agency.
+and maintained by `Tangent Labs`_, a London-based digital agency, with help from
+`Mirumee`.
 
 Oscar is released under the permissive `New BSD license`_.
 
 .. _`@codeinthehole`: https://twitter.com/codeinthehole
 .. _`Tangent Labs`: http://www.tangentlabs.co.uk
 .. _`New BSD license`: https://github.com/tangentlabs/django-oscar/blob/master/LICENSE
+.. _`Mirumee`: http://mirumee.com/
 
 Case studies
 ------------

docs/source/conf.py

 # All configuration values have a default; values that are commented out
 # serve to show the default.
 
-import sys, os
-oscar_folder = os.path.realpath(os.path.join(os.path.dirname(__file__), '../..'))
-sys.path.append(oscar_folder)
-
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
 #sys.path.insert(0, os.path.abspath('.'))
+import sys, os
+oscar_folder = os.path.realpath(os.path.join(os.path.dirname(__file__), '../..'))
+sys.path.append(oscar_folder)
+
+# Get django settings
+os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'sandbox.settings')
 
 # -- General configuration -----------------------------------------------------
 
 
 # General information about the project.
 project = u'django-oscar'
-copyright = u'2011, David Winterbottom'
+copyright = u'Tangent Labs'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the

docs/source/index.rst

 
 * Extension libraries available for PayPal, GoCardless, DataCash and more
 
+Oscar is a good choice if your domain has non-trivial business logic.  Oscar's
+flexibility means it's straightforward to implement business rules that would be
+difficult to apply in other frameworks.  
+
+Example requirements that Oscar applications already handle:
+
+* Paying for an order with multiple payment sources (eg using a bankcard,
+  voucher, giftcard and business account).
+
+* Complex access control rules governing who can view and order what.
+
+* Supporting a hierarchy of customers, sales reps and sales directors - each
+  being able to "masquerade" as their subordinate users.
+
+* Multi-lingual products and categories
+
 Oscar is developed by `Tangent Labs`_, a London-based digital agency.  It is
 used in production in several applications to sell everything from beer mats to
-ipads.  The `source is on Github`_. 
+ipads.  The `source is on Github`_ - contributions welcome.
 
 .. _`Tangent Labs`: http://www.tangentlabs.co.uk
 .. _`source is on Github`: https://github.com/tangentlabs/django-oscar

docs/source/recipes/how_to_configure_stock_messaging.rst

 ================================
 How to configure stock messaging
 ================================
+
+Stock messaging is controlled on a per-partner basis.  A product's stockrecord
+has the following methods for messaging:
+
+.. autoclass:: oscar.apps.partner.abstract_models.AbstractStockRecord
+    :members: availability, availability_code
+
+Both these methods delegate to a "partner wrapper" instance.  These are defined
+in the ``OSCAR_PARTNER_WRAPPERS`` setting which is a dict mapping from partner
+name to a class path, for instance::
+
+    # settings.py
+    OSCAR_PARTNER_WRAPPERS = {
+        'Partner A': 'myproject.wrappers.PartnerAWrapper',
+    }
+
+The default wrapper is :class:`oscar.apps.partner.wrappers.DefaultWrapper`,
+which provides methods of the same name.
+
+.. autoclass:: oscar.apps.partner.wrappers.DefaultWrapper
+    :members: availability, availability_code
+
+Custom wrappers should subclass this class and override the appropriate methods.
+Here's an example wrapper that provides custom availability messaging::
+
+    # myproject/wrappers.py
+    from oscar.apps.partner import wrappers
+
+
+    class PartnerAWrapper(wrappers.DefaultWrapper):
+        
+        def availability(self, stockrecord):
+            if stockrecord.net_stock_level > 0:
+                return "Available to buy now!"
+            return "Sorry, not available"
+
+        def availability_code(self, stockrecord):
+            if stockrecord.net_stock_level > 0:
+                return "icon_tick"
+            return "icon_cross"

docs/source/recipes/how_to_disable_an_app.rst

-=====================
-How to disable an app
-=====================
+============================
+How to disable an app's URLs
+============================
 
-...
+Suppose you don't want to use Oscar's dashboard but use your own.  The way to do
+this is to modify the URLs config to exclude the URLs from the app in question.
 
+You need to use your own root 'application' instance which gives you control
+over the URLs structure.  So your root ``urls.py`` should have::
+
+    # urls.py
+    from myproject.app import application
+
+    urlpatterns = patterns('',
+        ...
+        (r'', include(application.urls)),
+    )
+
+where ``application`` is a subclass of ``oscar.app.Shop`` which overrides the 
+link to the dashboard app::
+
+    # myproject/app.py
+    from oscar.app import Shop
+    from oscar.core.application import Application
+
+    class MyShop(Shop):
+
+        # Override the core dashboard_app instance to use a blank application 
+        # instance.  This means no dashboard URLs are included.
+        dashboard_app = Application()
+
+The only remaining task is to ensure your templates don't reference any
+dashboard URLs. 

docs/source/reference/signals.rst

 Signals
 =======
 
-Oscar defined a number of custom signals that provide useful hook-points for
+Oscar implements a number of custom signals that provide useful hook-points for
 adding functionality.
 
+product_viewed
+--------------
+
+.. data:: oscar.apps.catalogue.signals.product_viewed
+    :class:
+
+Raised when a product detail page is viewed.  
+
+Arguments sent with this signal:
+
+``product``
+    The product being viewed
+
+``user``
+    The user in question
+
+``request``
+    The request instance
+
+``response``
+    The response instance
+
+product_search
+--------------
+
+.. data:: oscar.apps.catalogue.signals.product_search
+    :class:
+
+Raised when a search is performed.
+
+Arguments sent with this signal:
+
+``query``
+    The search term
+
+``user``
+    The user in question
+
+basket_addition
+---------------
+
+.. data:: oscar.apps.basket.signals.basket_addition
+    :class:
+
+Raised when a product is added to a basket
+
+Arguments sent with this signal:
+
+``product``
+    The product being added
+
+``user``
+    The user in question
+
+voucher_addition
+----------------
+
+.. data:: oscar.apps.basket.signals.voucher_addition
+    :class:
+
+Raised when a valid voucher is added to a basket
+
+Arguments sent with this signal:
+
+``basket``
+    The basket in question
+
+``voucher``
+    The voucher in question
+
+pre_payment
+-----------
+
+.. data:: oscar.apps.checkout.signals.pre_payment
+    :class:
+
+Raised immediately before attempting to take payment in the checkout.
+
+Arguments sent with this signal:
+
+``view``
+    The view class instance
+
+post_payment
+------------
+
+.. data:: oscar.apps.checkout.signals.post_payment
+    :class:
+
+Raised immediately after payment has been taken.
+
+Arguments sent with this signal:
+
+``view``
+    The view class instance
+
 order_placed
 ------------
 
-.. data:: oscar.apps.order.order_placed
+.. data:: oscar.apps.order.signals.order_placed
     :class:
 
-Raised by the :class:`oscar.apps.order.OrderCreator` class when creating an order.
+Raised by the :class:`oscar.apps.order.utils.OrderCreator` class when creating an order.
 
 Arguments sent with this signal:
 

oscar/__init__.py

 # a full release
 
 VERSION = (0, 3, 0, 'alpha', 0)
-
+    
 def get_short_version():
     return '%s.%s' % (VERSION[0], VERSION[1])
 

oscar/app.py

         )
         return urlpatterns
     
-
-shop = Shop()
+# 'shop' kept for legacy projects - 'application' is a better name
+shop = application = Shop()

oscar/apps/basket/abstract_models.py

         self.discounts = []
         self._lines = None
 
-    def merge_line(self, line):
+    def merge_line(self, line, add_quantities=True):
         """
         For transferring a line from another basket to this one.
 
             line.basket = self
             line.save()
         else:
-            # Line already exists - bump its quantity and delete the old
-            existing_line.quantity += line.quantity
+            # Line already exists - assume the max quantity is correct and delete the old
+            if add_quantities:
+                existing_line.quantity += line.quantity
+            else:
+                existing_line.quantity = max(existing_line.quantity, line.quantity)
             existing_line.save()
             line.delete()
 
-    def merge(self, basket):
+    def merge(self, basket, add_quantities=True):
         """
         Merges another basket with this one.
+
+        :basket: The basket to merge into this one
+        :add_quantities: Whether to add line quantities when they are merged.
         """
         for line_to_merge in basket.all_lines():
-            self.merge_line(line_to_merge)
+            self.merge_line(line_to_merge, add_quantities)
         basket.status = MERGED
         basket.date_merged = datetime.datetime.now()
         basket.save()
         shipping.
         """
         for line in self.all_lines():
-            if line.product.os_shipping_required:
+            if line.product.is_shipping_required:
                 return True
         return False
 

oscar/apps/basket/middleware.py

         
         This is its own method to allow it to be overridden
         """
-        master.merge(slave)    
+        master.merge(slave, add_quantities=False)
         
     def process_response(self, request, response):
         # Delete any surplus cookies

oscar/apps/basket/signals.py

 import django.dispatch
 
 basket_addition = django.dispatch.Signal(providing_args=["product", "user"])
-basket_voucher = django.dispatch.Signal(providing_args=["basket", "voucher"])
+voucher_addition = django.dispatch.Signal(providing_args=["basket", "voucher"])

oscar/apps/basket/views.py

 from django.core.exceptions import ObjectDoesNotExist
 
 from extra_views import ModelFormSetView
-from oscar.apps.basket.signals import basket_addition
+from oscar.apps.basket.signals import basket_addition, voucher_addition
 from oscar.core.loading import get_class, get_classes
 Applicator = get_class('offer.utils', 'Applicator')
 BasketLineForm, AddToBasketForm, BasketVoucherForm, \
 class VoucherAddView(FormView):
     form_class = BasketVoucherForm
     voucher_model = get_model('voucher', 'voucher')
+    add_signal = voucher_addition
 
     def get(self, request, *args, **kwargs):
         return HttpResponseRedirect(reverse('basket:summary'))
 
         self.request.basket.vouchers.add(voucher)
 
+        # Raise signal
+        self.add_signal.send(sender=self, 
+                             basket=self.request.basket, 
+                             voucher=voucher)
+
         # Recalculate discounts to see if the voucher gives any
         discounts_before = self.request.basket.get_discounts()
         self.request.basket.remove_discounts()

oscar/apps/catalogue/signals.py

 import django.dispatch
 
 product_viewed = django.dispatch.Signal(providing_args=["product", "user", "request", "response"])
+
+# This needs to be moved into the search app when it is refactored
 product_search = django.dispatch.Signal(providing_args=["query", '"user'])

oscar/apps/checkout/forms.py

         super(ShippingAddressForm,self ).__init__(*args, **kwargs)
         self.set_country_queryset() 
         
-    def set_country_queryset(self):    
-        self.fields['country'].queryset = get_model('address', 'country')._default_manager.filter(is_shipping_country=True)
+    def set_country_queryset(self):
+        self.fields['country'].queryset = get_model('address', 'country')._default_manager.filter(
+            is_shipping_country=True)
     
     class Meta:
         model = get_model('order', 'shippingaddress')

oscar/apps/checkout/signals.py

 from django.dispatch import Signal
 
 pre_payment = Signal(providing_args=["view"])
-post_payment = Signal(providing_args=["view"])
-order_placed = Signal(providing_args=["order"])
+post_payment = Signal(providing_args=["view"])

oscar/apps/checkout/utils.py

     def reset_shipping_data(self):
         self._flush_namespace('shipping')
 
-    def no_shipping_required(self):
-        """
-        Record fact that basket doesn't require a shipping address or method
-        """
-        self.reset_shipping_data()
-        self._set('shipping', 'is_required', False)
-
-    def shipping_required(self):
-        """
-        Record fact that basket does require a shipping address or method
-        """
-        self.reset_shipping_data()
-        self._set('shipping', 'is_required', True)
-
     def ship_to_user_address(self, address):
         """
         Set existing shipping address id to session and unset address fields from session
         return self._get('shipping', 'user_address_id')
     user_address_id = shipping_user_address_id
 
-    def is_shipping_required(self):
-        return self._get('shipping', 'is_required', True)
-
     def is_shipping_address_set(self):
+        """
+        Test whether a shipping address has been stored in the session.
+
+        This can be from a new address or re-using an existing address.
+        """
         new_fields = self.new_shipping_address_fields()
         has_new_address = new_fields is not None
         has_old_address = self.user_address_id() > 0

oscar/apps/checkout/views.py

     form_class = ShippingAddressForm
 
     def get(self, request, *args, **kwargs):
+        # Check that the user's basket is not empty
+        if request.basket.is_empty:
+            messages.error(request, _("You need to add some items to your basket to checkout"))
+            return HttpResponseRedirect(reverse('basket:summary'))
+
         # Check that guests have entered an email address
         if not request.user.is_authenticated() and not self.checkout_session.get_guest_email():
             messages.error(request, _("Please either sign in or enter your email address"))
 
         # Check to see that a shipping address is actually required.  It may not be if
         # the basket is purely downloads
-        if not self.does_basket_require_shipping(request.basket):
+        if not request.basket.is_shipping_required():
             messages.info(request, _("Your basket does not require a shipping address to be submitted"))
-            self.checkout_session.no_shipping_required()
             return HttpResponseRedirect(self.get_success_url())
-        else:
-            self.checkout_session.shipping_required()
 
         return super(ShippingAddressView, self).get(request, *args, **kwargs)
 
-    def does_basket_require_shipping(self, basket):
-        """
-        Test whether the contents of the basket require shipping
-        """
-        return basket.is_shipping_required()
-
     def get_initial(self):
         return self.checkout_session.new_shipping_address_fields()
 
     template_name = 'checkout/shipping_methods.html';
 
     def get(self, request, *args, **kwargs):
+        # Check that the user's basket is not empty
+        if request.basket.is_empty:
+            messages.error(request, _("You need to add some items to your basket to checkout"))
+            return HttpResponseRedirect(reverse('basket:summary'))
+
         # Check that shipping is required at all
-        if not self.checkout_session.is_shipping_required():
+        if not request.basket.is_shipping_required():
             self.checkout_session.use_shipping_method(NoShippingRequired().code)
             return self.get_success_response()
 
     """
 
     def get(self, request, *args, **kwargs):
+        # Check that the user's basket is not empty
+        if request.basket.is_empty:
+            messages.error(request, _("You need to add some items to your basket to checkout"))
+            return HttpResponseRedirect(reverse('basket:summary'))
+
         # Check that shipping address has been completed
-        if self.checkout_session.is_shipping_required() and not self.checkout_session.is_shipping_address_set():
+        if request.basket.is_shipping_required() and not self.checkout_session.is_shipping_address_set():
             messages.error(request, _("Please choose a shipping address"))
             return HttpResponseRedirect(reverse('checkout:shipping-address'))
+
         # Check that shipping method has been set
         if not self.checkout_session.is_shipping_method_set():
             messages.error(request, _("Please choose a shipping method"))
         If the shipping address was selected from the user's address book,
         then we convert the UserAddress to a ShippingAddress.
         """
-        if not self.checkout_session.is_shipping_required():
+        if not self.request.basket.is_shipping_required():
             return None
 
         addr_data = self.checkout_session.new_shipping_address_fields()
         return [self.template_name_preview] if self.preview else [self.template_name]
 
     def get_error_response(self):
+        # Check that the user's basket is not empty
+        if self.request.basket.is_empty:
+            messages.error(self.request, _("You need to add some items to your basket to checkout"))
+            return HttpResponseRedirect(reverse('basket:summary'))
         # Check that shipping address has been completed
-        if self.checkout_session.is_shipping_required() and not self.checkout_session.is_shipping_address_set():
+        if self.request.basket.is_shipping_required() and not self.checkout_session.is_shipping_address_set():
             messages.error(self.request, _("Please choose a shipping address"))
             return HttpResponseRedirect(reverse('checkout:shipping-address'))
         # Check that shipping method has been set
         then the method can call submit()
         """
         error_response = self.get_error_response()
+        
         if error_response:
             return error_response
         if self.preview:
         # Next, check that basket isn't empty
         if basket.is_empty:
             messages.error(self.request, _("This order cannot be submitted as the basket is empty"))
-            url = self.request.META.get('HTTP_REFERER', reverse('checkout:shipping-address'))
+            url = self.request.META.get('HTTP_REFERER', reverse('basket:summary'))
             return HttpResponseRedirect(url)
 
         # Domain-specific checks on the basket

oscar/apps/dashboard/catalogue/views.py

         image_formset = ProductImageFormSet(self.request.POST,
                                             self.request.FILES,
                                             instance=product)
-        if stockrecord_form.is_valid() and category_formset.is_valid() and image_formset.is_valid():
+        if all([stockrecord_form.is_valid(), category_formset.is_valid(), image_formset.is_valid()]):
             # Save product
             product.save()
             # Save stock record
         image_formset = ProductImageFormSet(self.request.POST,
                                             self.request.FILES,
                                             instance=self.object)
-        if stockrecord_form.is_valid() and category_formset.is_valid() and image_formset.is_valid():
+        if all([stockrecord_form.is_valid(), category_formset.is_valid(), image_formset.is_valid()]):
             form.save()
             stockrecord_form.save()
             category_formset.save()

oscar/apps/partner/abstract_models.py

     @property
     def availability_code(self):
         """
-        Return an item's availability as a code for use in CSS
+        Return an product's availability as a code for use in CSS to add icons
+        to the overall availability mark-up.  For example, "instock",
+        "unavailable".
         """
         return get_partner_wrapper(self.partner.name).availability_code(self)
     
     @property
     def availability(self):
         """
-        Return an item's availability as a string
+        Return a product's availability as a string that can be displayed to the
+        user.  For example, "In stock", "Unavailabl".
         """
         return get_partner_wrapper(self.partner.name).availability(self)
 
-    def max_purchase_quantity(self, user):
+    def max_purchase_quantity(self, user=None):
         """
         Return an item's availability as a string
+
+        :param user: (optional) The user who wants to purchase
         """
-        return get_partner_wrapper(self.partner.name).availability(self)
+        return get_partner_wrapper(self.partner.name).max_purchase_quantity(self, user)
     
     @property
     def dispatch_date(self):

oscar/apps/partner/wrappers.py

         Return a code for the availability of this product.
 
         This is normally used within CSS to add icons to stock messages
+
+        :param oscar.apps.partner.models.StockRecord stockrecord: stockrecord instance
         """
         if stockrecord.net_stock_level > 0:
             return 'instock'
         return 'outofstock'
     
     def availability(self, stockrecord):
+        """
+        Return an availability message for the passed stockrecord.
+
+        :param oscar.apps.partner.models.StockRecord stockrecord: stockrecord instance
+        """
         if stockrecord.net_stock_level > 0:
             return _("In stock (%d available)" % stockrecord.net_stock_level)
         if self.is_available_to_buy(stockrecord):

oscar/apps/shipping/repository.py

     Repository class responsible for returning ShippingMethod
     objects for a given user, basket etc
     """
-    
+
     def get_shipping_methods(self, user, basket, shipping_addr=None, **kwargs):
         """
         Return a list of all applicable shipping method objects
         for a given basket.
-        
+
         We default to returning the Method models that have been defined but
         this behaviour can easily be overridden by subclassing this class
         and overriding this method.
-        """ 
+        """
         methods = [Free()]
         return self.add_basket_to_methods(basket, methods)
 
         methods = self.get_shipping_methods(user, basket, shipping_addr, **kwargs)
         if len(methods) == 0:
             raise ImproperlyConfigured("You need to define some shipping methods")
-        return methods[0]
+        return min(methods, key=lambda method: method.basket_charge_incl_tax())
 
     def add_basket_to_methods(self, basket, methods):
         for method in methods:

oscar/apps/voucher/abstract_models.py

         """
         Records a usage of this voucher in an order.
         """
-        self.applications.create(voucher=self, order=order, user=user)
+        if user.is_authenticated():
+            self.applications.create(voucher=self, order=order, user=user)
+        else:
+            self.applications.create(voucher=self, order=order)
 
     @property
     def benefit(self):
     For tracking how often a voucher has been used
     """
     voucher = models.ForeignKey('voucher.Voucher', related_name="applications")
+
     # It is possible for an anonymous user to apply a voucher so we need to allow
     # the user to be nullable
     user = models.ForeignKey('auth.User', blank=True, null=True)

oscar/templates/customer/anon-order.html

 </div>
 {% endblock header %}
 
-
 {% block content %}
+<div class="sub-header">
+    <h3>Status</h3>
+</div>
+<p>{{ order.status }}</p>
+
 <div class="sub-header">
     <h3>Shipping address</h3>
 </div>

oscar/templates/dashboard/orders/order_detail.html

 
     <h3>Customer Information</h3>
 	{% if order.user %}
-	
+
     <div class="row-fluid">
         <div class="span4">
             <div class="well well-info">
 
 <div class="tabbable dashboard">
 	<ul class="nav nav-tabs">
+	{% block nav_tabs %}
 		<li class="active"><a href="#lines" data-toggle="tab">Order contents</a></li>
 		<li><a href="#shipping" data-toggle="tab">Shipping</a></li>
 		<li><a href="#payment" data-toggle="tab">Payment</a></li>
 		<li><a href="#discounts" data-toggle="tab">Discounts</a></li>
 		<li><a href="#emails" data-toggle="tab">Emails</a></li>
 		<li><a href="#notes" data-toggle="tab">Notes</a></li>
+	{% endblock nav_tabs %}
 	</ul>
 
 	<div class="tab-content">
 							</select>
 						</label>
 						<label class="radio inline">
-							with amount <input type="text" name="amount" value="" /> 
+							with amount <input type="text" name="amount" value="" />
 						</label>
 					</div>
 				</div>
 				<h3 class="app-ico ico_mapmarker icon">Payment sources</h3>
 			</div>
 			{% if sources %}
-				<table class="table table-striped table-bordered">    
-					<thead>  
+				<table class="table table-striped table-bordered">
+					<thead>
 						<tr>
 							<th>Source</th>
 							<th>Allocation</th>
 							<th>Amount debited</th>
 							<th>Amount refunded</th>
-						</tr>  
-					</thead>	
-					<tbody> 
+						</tr>
+					</thead>
+					<tbody>
 						{% for source in sources %}
 						<tr>
 							<td>{{ source.source_type }}</td>
 							<td>{{ source.amount_refunded|currency }}</td>
 						</tr>
 						{% endfor %}
-					</tbody>	
+					</tbody>
 				</table>
 			{% else %}
 				<p>No payment sources</p>
 			</form>
 			{% endblock %}
 		</div>
+
+		{% block extra_tabs %}{% endblock %}
 	</div>
 </div>
 

oscar/templates/dashboard/reviews/review_list.html

         <tr>
             <td><input type="checkbox" name="selected_review" class="selected_review" value="{{ review.id }}"/>
                 <td>
-                    <a href="{% url catalogue:reviews-detail review.product.slug review.product.id review.id %}">{{ review.title }}</a>
+					{% if review.product %}
+						<a href="{% url catalogue:reviews-detail review.product.slug review.product.id review.id %}">{{ review.title }}</a>
+					{% else %}
+						{{ review.title }}
+					{% endif %}
                 </td>
             <td>
-                <a href='{% url catalogue:detail review.product.slug review.product.id %}'>{{ review.product.title }}</a> </td>
+				{% if review.product %}
+					<a href='{% url catalogue:detail review.product.slug review.product.id %}'>{{ review.product.title }}</a> </td>
+				{% else %}
+					[Product deleted]
+				{% endif %}
             <td>
 				{% if review.user %}
                 <a href="{% url dashboard:user-detail review.user.id %}">{{ review.get_reviewer_name }}</a>

oscar/templates/dashboard/vouchers/voucher_delete.html

 		{% csrf_token %}
 		<div class="form-actions">
 			<button class="btn btn-danger btn-large" type="submit">Delete</button> or
-			<a href="{% url dashboard:range-list %}">cancel</a>
+			<a href="{% url dashboard:voucher-list %}">cancel</a>
 		</div>
 	</form>
 

oscar/test/__init__.py

 from django.test import TestCase
 from django.test.client import Client
 from django.contrib.auth.models import User
+from django.core.urlresolvers import reverse
 from purl import URL
 
 
             location = URL.from_string(response['Location'])
             self.assertEqual(expected_url, location.path())
 
-
+    def assertRedirectUrlName(self, response, name):
+        self.assertIsRedirect(response)
+        location = response['Location'].replace('http://testserver', '')
+        self.assertEqual(location, reverse(name))
 
     def assertIsOk(self, response):
         self.assertEqual(httplib.OK, response.status_code)

oscar/test/helpers.py

-from StringIO import StringIO
 from decimal import Decimal as D
 import random
-
-from django.test import TestCase
-from django.core.servers.basehttp import AdminMediaHandler
-from django.core.handlers.wsgi import WSGIHandler
-from django.core.urlresolvers import reverse
+import datetime
 
 from oscar.apps.basket.models import Basket
 from oscar.apps.catalogue.models import ProductClass, Product, ProductAttribute, ProductAttributeValue
 from oscar.apps.partner.models import Partner, StockRecord
 from oscar.apps.shipping.methods import Free
 from oscar.apps.offer.models import Range, ConditionalOffer, Condition, Benefit
+from oscar.apps.voucher.models import Voucher
 
 
 def create_product(price=None, title="Dummy title", product_class="Dummy item class",
 
 
 def create_offer():
+    """
+    Helper method for creating an offer
+    """
     range = Range.objects.create(name="All products range", includes_all_products=True)
     condition = Condition.objects.create(range=range,
                                          type=Condition.COUNT,
     benefit = Benefit.objects.create(range=range,
                                      type=Benefit.PERCENTAGE,
                                      value=20)
-    offer= ConditionalOffer.objects.create(
+    offer = ConditionalOffer.objects.create(
         name='Dummy offer',
         offer_type='Site',
         condition=condition,
     return offer
 
 
-
-
-class TwillTestCase(TestCase):
+def create_voucher():
     """
-    Simple wrapper around Twill to make writing TestCases easier.
-
-    Commands availabel through self.command are:
-    - go        -> visit a URL
-    - back      -> back to previous URL
-    - reload    -> reload URL
-    - follow    -> follow a given link
-    - code      -> assert the HTTP response code
-    - find      -> assert page contains some string
-    - notfind   -> assert page does not contain
-    - title     -> assert page title
+    Helper method for creating a voucher
     """
-
-    HOST = '127.0.0.1'
-    PORT = 8080
-
-    def setUp(self):
-        app = AdminMediaHandler(WSGIHandler())
-        twill.add_wsgi_intercept(self.HOST, self.PORT, lambda: app)
-        twill.set_output(StringIO())
-        self.command = twill.commands
-
-    def tearDown(self):
-        twill.remove_wsgi_intercept(self.HOST, self.PORT)
-
-    def reverse(self, url_name, *args, **kwargs):
-        """
-        Custom 'reverse' function that includes the protocol and host
-        """
-        return 'http://%s:%d%s' % (self.HOST, self.PORT, reverse(url_name, *args, **kwargs))
-
-    def visit(self, url_name, *args,**kwargs):
-        self.command.go(self.reverse(url_name, *args, **kwargs))
-
-    def assertResponseCodeIs(self, code):
-        self.command.code(code)
-
-    def assertPageContains(self, regexp):
-        self.command.find(regexp)
-
-    def assertPageDoesNotContain(self, regexp):
-        self.command.notfind(regexp)
-
-    def assertPageTitleMatches(self, regexp):
-        self.command.title(regexp)
-
+    voucher = Voucher.objects.create(
+        name="Test voucher",
+        code="test",
+        start_date=datetime.date.today(),
+        end_date=datetime.date.today() + datetime.timedelta(days=12)
+    )
+    voucher.offers.add(create_offer())
+    return voucher

tests/config.py

 from django.conf import settings, global_settings
 from oscar import OSCAR_CORE_APPS
 
+
 def configure():
     if not settings.configured:
         from oscar.defaults import OSCAR_SETTINGS
             HAYSTACK_SEARCH_ENGINE='dummy',
             HAYSTACK_SITECONF = 'oscar.search_sites',
             APPEND_SLASH=True,
-            NOSE_ARGS=['-s', '-x', '--with-spec'],
+            NOSE_ARGS=['-s', '-x'],
             **OSCAR_SETTINGS
         )

tests/functional/basket_tests.py

 from decimal import Decimal as D
 import httplib
+import datetime
 
 from django.contrib.auth.models import User
 from django.conf import settings
 
 from oscar.test.helpers import create_product
 from oscar.apps.basket.models import Basket
+from oscar.apps.basket import reports
+
+
+class BasketMergingTests(TestCase):
+
+    def setUp(self):
+        self.product = create_product()
+        self.user_basket = Basket()
+        self.user_basket.add_product(self.product)
+        self.cookie_basket = Basket()
+        self.cookie_basket.add_product(self.product, 2)
+        self.user_basket.merge(self.cookie_basket, add_quantities=False)
+
+    def test_cookie_basket_has_status_set(self):
+        self.assertEqual('Merged', self.cookie_basket.status)
+
+    def test_lines_are_moved_across(self):
+        self.assertEqual(1, self.user_basket.lines.all().count())
+
+    def test_merge_line_takes_max_quantity(self):
+        line = self.user_basket.lines.get(product=self.product)
+        self.assertEqual(2, line.quantity)
 
 
 class AnonAddToBasketViewTests(TestCase):
                         response.cookies['messages'].value)
 
 
+class BasketReportTests(TestCase):
+
+    def test_open_report_doesnt_error(self):
+        data = {
+            'start_date': datetime.date(2012, 5, 1),
+            'end_date': datetime.date(2012, 5, 17),
+            'formatter': 'CSV'
+        }
+        generator = reports.OpenBasketReportGenerator(**data)
+        generator.generate()
+
+    def test_submitted_report_doesnt_error(self):
+        data = {
+            'start_date': datetime.date(2012, 5, 1),
+            'end_date': datetime.date(2012, 5, 17),
+            'formatter': 'CSV'
+        }
+        generator = reports.SubmittedBasketReportGenerator(**data)
+        generator.generate()
+
+
 class SavedBasketTests(TestCase):
 
     def test_moving_from_saved_basket(self):

tests/functional/checkout_tests.py

 from django.conf import settings
 from django.utils.importlib import import_module
 
-from oscar.test.helpers import create_product
+from oscar.test.helpers import create_product, create_voucher
 from oscar.test import ClientTestCase, patch_settings
 from oscar.apps.basket.models import Basket
 from oscar.apps.order.models import Order
+from oscar.apps.address.models import Country
 
 
 class CheckoutMixin(object):
-    fixtures = ['countries.json']
+
+    def add_product_to_basket(self):
+        product = create_product(price=D('12.00'))
+        self.client.post(reverse('basket:add'), {'product_id': product.id,
+                                                 'quantity': 1})
+
+    def add_voucher_to_basket(self):
+        voucher = create_voucher()
+        self.client.post(reverse('basket:vouchers-add'),
+                         {'code': voucher.code})
 
     def complete_guest_email_form(self, email='test@example.com'):
         response = self.client.post(reverse('checkout:index'),
         self.assertIsRedirect(response)
 
     def complete_shipping_address(self):
+        Country.objects.get_or_create(
+            iso_3166_1_a2='GB',
+            is_shipping_country=True
+        )
         response = self.client.post(reverse('checkout:shipping-address'),
                                      {'last_name': 'Doe',
                                       'line1': '1 Egg Street',
     def complete_shipping_method(self):
         self.client.get(reverse('checkout:shipping-method'))
 
-    def assertRedirectUrlName(self, response, name):
-        location = response['Location'].replace('http://testserver', '')
-        self.assertEqual(location, reverse(name))
+    def submit(self):
+        return self.client.post(reverse('checkout:preview'), {'action': 'place_order'})
 
 
 class DisabledAnonymousCheckoutViewsTests(ClientTestCase):
             self.assertEqual('barry@example.com', order.guest_email)
 
 
-class ShippingAddressViewTests(ClientTestCase):
+class TestShippingAddressView(ClientTestCase, CheckoutMixin):
     fixtures = ['countries.json']
+
+    def test_pages_returns_200(self):
+        self.add_product_to_basket()
+        response = self.client.get(reverse('checkout:shipping-address'))
+        self.assertIsOk(response)
     
     def test_anon_checkout_disabled_by_default(self):
         self.assertFalse(settings.OSCAR_ALLOW_ANON_CHECKOUT)
         self.assertEqual('1 Egg Street', session_address['line1'])
         self.assertEqual('N1 9RT', session_address['postcode'])
 
+    def test_user_must_have_a_nonempty_basket(self):
+        response = self.client.get(reverse('checkout:shipping-address'))
+        self.assertRedirectUrlName(response, 'basket:summary')
 
-class ShippingMethodViewTests(ClientTestCase, CheckoutMixin):
+
+class TestShippingMethodView(ClientTestCase, CheckoutMixin):
     fixtures = ['countries.json']
 
     def test_shipping_method_view_redirects_if_no_shipping_address(self):
+        self.add_product_to_basket()
         response = self.client.get(reverse('checkout:shipping-method'))
         self.assertIsRedirect(response)
         self.assertRedirectUrlName(response, 'checkout:shipping-address')
 
     def test_redirects_by_default(self):
+        self.add_product_to_basket()
         self.complete_shipping_address()
         response = self.client.get(reverse('checkout:shipping-method'))
         self.assertRedirectUrlName(response, 'checkout:payment-method')
 
+    def test_user_must_have_a_nonempty_basket(self):
+        response = self.client.get(reverse('checkout:shipping-method'))
+        self.assertRedirectUrlName(response, 'basket:summary')
 
-class PaymentMethodViewTests(ClientTestCase, CheckoutMixin):
+
+class TestPaymentMethodView(ClientTestCase, CheckoutMixin):
 
     def test_view_redirects_if_no_shipping_address(self):
+        self.add_product_to_basket() 
         response = self.client.get(reverse('checkout:payment-method'))
         self.assertIsRedirect(response)
         self.assertRedirectUrlName(response, 'checkout:shipping-address')
 
     def test_view_redirects_if_no_shipping_method(self):
+        self.add_product_to_basket() 
         self.complete_shipping_address()
         response = self.client.get(reverse('checkout:payment-method'))
         self.assertIsRedirect(response)
         self.assertRedirectUrlName(response, 'checkout:shipping-method')
 
+    def test_user_must_have_a_nonempty_basket(self):
+        response = self.client.get(reverse('checkout:payment-method'))
+        self.assertRedirectUrlName(response, 'basket:summary')
+
 
-class PreviewViewTests(ClientTestCase, CheckoutMixin):
+class TestPreviewView(ClientTestCase, CheckoutMixin):
+
+    def test_user_must_have_a_nonempty_basket(self):
+        response = self.client.get(reverse('checkout:preview'))
+        self.assertRedirectUrlName(response, 'basket:summary')
 
     def test_view_redirects_if_no_shipping_address(self):
+        self.add_product_to_basket()
         response = self.client.get(reverse('checkout:preview'))
         self.assertIsRedirect(response)
         self.assertRedirectUrlName(response, 'checkout:shipping-address')
 
     def test_view_redirects_if_no_shipping_method(self):
+        self.add_product_to_basket()
         self.complete_shipping_address()
         response = self.client.get(reverse('checkout:preview'))
         self.assertIsRedirect(response)
         self.assertRedirectUrlName(response, 'checkout:shipping-method')
 
     def test_ok_response_if_previous_steps_complete(self):
+        self.add_product_to_basket()
         self.complete_shipping_address()
         self.complete_shipping_method()
         response = self.client.get(reverse('checkout:preview'))
 
 class PaymentDetailsViewTests(ClientTestCase, CheckoutMixin):
 
+    def test_user_must_have_a_nonempty_basket(self):
+        response = self.client.get(reverse('checkout:payment-details'))
+        self.assertRedirectUrlName(response, 'basket:summary')
+
     def test_view_redirects_if_no_shipping_address(self):
+        self.add_product_to_basket()
         response = self.client.post(reverse('checkout:payment-details'))
         self.assertIsRedirect(response)
         self.assertRedirectUrlName(response, 'checkout:shipping-address')
 
     def test_view_redirects_if_no_shipping_method(self):
+        self.add_product_to_basket()
         self.complete_shipping_address()
         response = self.client.post(reverse('checkout:payment-details'))
         self.assertIsRedirect(response)
         self.assertRedirectUrlName(response, 'checkout:shipping-method')
 
     def test_placing_order_with_empty_basket_redirects(self):
-        self.complete_shipping_address()
-        self.complete_shipping_method()
         response = self.client.post(reverse('checkout:preview'), {'action': 'place_order'})
         self.assertIsRedirect(response)
-        self.assertRedirectUrlName(response, 'checkout:shipping-address')
+        self.assertRedirectUrlName(response, 'basket:summary')
 
 
 class OrderPlacementTests(ClientTestCase, CheckoutMixin):
         self.assertIsRedirect(self.response)
         orders = Order.objects.all()
         self.assertEqual(1, len(orders))
+        
+
+class TestAnonUserOrderPlacementScenarios(ClientTestCase, CheckoutMixin):
+
+    def test_basic_submission_gets_redirect_to_thankyou(self):
+        self.add_product_to_basket()
+        self.complete_shipping_address()
+        self.complete_shipping_method()
+        response = self.submit()
+        self.assertRedirectUrlName(response, 'checkout:thank-you')
+
+    def test_submission_using_voucher(self):
+        self.add_product_to_basket()
+        self.add_voucher_to_basket()
+        self.complete_shipping_address()
+        self.complete_shipping_method()
+        response = self.submit()
+        self.assertRedirectUrlName(response, 'checkout:thank-you')

tests/unit/partner/model_tests.py

         self.assertEqual(0, self.stockrecord.num_allocated)
         self.assertEqual(10, self.stockrecord.num_in_stock)
 
+    def test_max_purchase_quantity(self):
+        self.assertEqual(10, self.stockrecord.max_purchase_quantity())
+
 
 class DefaultWrapperTests(TestCase):