def test_oops_there_is_more_than_one(self):
        Site.objects.create(hostname="example.com", is_default_site=True, root_page=Page.objects.get(pk=2))

        site = Site(hostname="test.com", is_default_site=True, root_page=Page.objects.get(pk=2))
        with self.assertRaises(Site.MultipleObjectsReturned):
            # If there already are multiple default sites, you're in trouble
            site.clean_fields()

    def test_duplicate_slug(self):
        from wagtail.wagtailcore.models import Site
        # Create a test Site with a root page
        root = models.TestRootPage(title='title', depth=1, path='0001', slug_en='slug_en', slug_de='slug_de')
        root.save()

        site = Site(root_page=root)
        site.save()

        # Add children to the root
        child = root.add_child(
            instance=models.TestSlugPage1(title='child1', slug_de='child', slug_en='child-en', depth=2, path='00010001')
        )

        child2 = root.add_child(
            instance=models.TestSlugPage2(title='child2', slug_de='child-2', slug_en='child2-en', depth=2,
                                          path='00010002')
        )

        # Clean should work fine as the two slugs are different
        child2.clean()

        # Make the slug equal to test if the duplicate is detected
        child2.slug_de = 'child'

        self.assertRaises(ValidationError, child2.clean)

    def test_get_unit_chat_link(self):
        """
        Test that pages in the site get the correct ask a librarian 
        link to their corresoinding AskPage and chat widget. Eckhart 
        and SCRC are treated differently since they're circumstances
        are slightly different.
        """
        ask_widgets = set(['law', 'crerar', 'ssa', 'uofc-ask', 'dissertation-office'])

        # Dictionary of tuples where the keys map to the ask_widget_name field  
        # of AskPages. The firs item of the tuple is a mixed dictionary of 
        # location/hours/unit information and the second item of the tuple is 
        # a random url belonging to a page of a given section of the site.
        data = {
            'law': (get_hours_and_location(StandardPage.objects.get(id=DANGELO_HOMEPAGE)), '/law/services/carrelslockers/'),
            'crerar': (get_hours_and_location(StandardPage.objects.get(id=CRERAR_HOMEPAGE)), '/crerar/science-research-services/data-support-services/'),
            'ssa': (get_hours_and_location(StandardPage.objects.get(id=SSA_HOMEPAGE)), '/ssa/about/'),
            'uofc-ask': (get_hours_and_location(StandardPage.objects.get(id=PUBLIC_HOMEPAGE)), '/research/help/offcampus/'),
            'dissertation-office': (get_hours_and_location(StandardPage.objects.get(id=DISSERTATION_HOMEPAGE)), '/research/scholar/phd/students/'),
            'eck': (get_hours_and_location(StandardPage.objects.get(id=ECKHART_HOMEPAGE)), '/eck/mathematics-research-services/'),
            'scrc': (get_hours_and_location(StandardPage.objects.get(id=SCRC_HOMEPAGE)), '/scrc/visiting/'),
        }

        # Normal chat links to regular AskPages
        for item in ask_widgets:
            request = HttpRequest()
            request.path = data[item][1]
            current_site = Site.find_for_request(request)

            a = get_unit_chat_link(data[item][0]['page_unit'], request)
            b = AskPage.objects.filter(ask_widget_name=item).first().relative_url(current_site)

            self.assertEqual(a, b)

        # Eckhart
        request_eck = HttpRequest()
        request_eck.path = data['eck'][1]
        current_site = Site.find_for_request(request_eck)
        eckurl = get_unit_chat_link(data['eck'][0]['page_unit'], request_eck)
        eckask = AskPage.objects.get(id=4646).relative_url(current_site)
        self.assertEqual(eckurl, eckask)


        # SCRC
        request_scrc = HttpRequest()
        request_scrc.path = data['scrc'][1]
        current_site = Site.find_for_request(request_scrc)
        scrcurl = get_unit_chat_link(data['scrc'][0]['page_unit'], request_scrc)
        scrcask = PublicRawHTMLPage.objects.get(id=4127).relative_url(current_site)
        self.assertEqual(scrcurl, scrcask)

 def get_context(self, request):
     context = super(ConferenceSubPage, self).get_context(request)
     current_site = Site.find_for_request(request)
     context['banner_image'] = self.get_parent().conferencepage.banner_image
     context['branding_color'] = self.get_parent().conferencepage.branding_color
     context['conference_logo'] = self.get_parent().conferencepage.conference_logo 
     context['conference_title'] = self.get_parent().title
     context['conference_subtitle'] = self.get_parent().conferencepage.subtitle
     context['conference_tagline'] = self.get_parent().conferencepage.tagline
     context['has_social_media'] = self.get_parent().conferencepage.has_social_media
     context['main_registration'] = self.get_parent().conferencepage.main_registration.all()
     context['sponsors'] = self.get_parent().conferencepage.sponsors.all()
     context['organizers'] = self.get_parent().conferencepage.organizers.all()
     context['twitter_page'] = self.get_parent().conferencepage.twitter_page 
     context['facebook_page'] = self.get_parent().conferencepage.facebook_page
     context['hashtag_page'] = self.get_parent().conferencepage.hashtag_page
     context['hashtag'] = self.get_parent().conferencepage.hashtag
     context['instagram_page'] = self.get_parent().conferencepage.instagram_page
     context['youtube_page'] = self.get_parent().conferencepage.youtube_page
     context['blog_page'] = self.get_parent().conferencepage.blog_page
     context['tumblr_page'] = self.get_parent().conferencepage.tumblr_page
     context['snapchat_page'] = self.get_parent().conferencepage.snapchat_page
     context['secondary_registration'] = self.get_parent().conferencepage.sub_registration.all()
     context['secondary_registration_heading'] = self.get_parent().conferencepage.secondary_registration_heading
     context['secondary_registration_description'] = self.get_parent().conferencepage.secondary_registration_description
     context['home'] = self.get_parent().conferencepage.relative_url(current_site)
     return context

 def test_with_server_name(self):
     request = HttpRequest()
     request.META = {
         'SERVER_NAME': 'example.com',
         'SERVER_PORT': 80
     }
     self.assertEqual(Site.find_for_request(request), self.site)

def scan(request):
    site = Site.find_for_request(request)
    broken_links = broken_link_scan(site)

    return render(request, 'wagtaillinkchecker/results.html', {
        'broken_links': broken_links,
    })

 def test_unrecognised_host_header_routes_to_default_site(self):
     # requests with an unrecognised Host: header should be directed to the default site
     request = HttpRequest()
     request.path = '/'
     request.META['HTTP_HOST'] = self.unrecognised_hostname
     request.META['SERVER_PORT'] = '80'
     self.assertEqual(Site.find_for_request(request), self.default_site)

 def _import_pages (self, exported_page_data):
     # Delete any existing pages.
     for page in Page.objects.all():
         page.delete()
     with open(exported_page_data, 'r') as fh:
         page_data = cPickle.load(fh)
     for page_name, info in page_data.items():
         self.logger.debug('Creating page {}'.format(page_name))
         page = info['class'](**info['kwargs'])
         page.save()
         self._pages[page_name] = page
     # Add a Wagtail Site, or nothing will appear anywhere.
     home_page = HomePage.objects.all()[0]
     site = Site(hostname='localhost', root_page=home_page,
                 is_default_site=True)
     site.save()

def live_preview(request):

    try:
        if u'/' == request.path:
            page = Site.find_for_request(request).root_page.specific
        else:
            logger.info("path: %s", '//'+request.path)
            page = Page.objects.get(url_path='//'+request.path).specific
    except Page.DoesNotExist:
        return {}

    content_file = os.path.join(settings.BOOTSTRAP_CONTENT_DIR, 'pages', request.path.strip('/') + '.yml')
    if not os.path.isfile(content_file):
        return {}

    content_attributes = load_attributes_from_file(content_file)

    try:
        del content_attributes['type']
    except KeyError:
        pass

    SiteNode.set_page_attributes(page, content_attributes, get_relation_mappings())

    return {'self': page}

 def test_ports_in_request_headers_are_respected(self):
     # ports in the Host: header should be respected
     request = HttpRequest()
     request.path = '/'
     request.META['HTTP_HOST'] = self.alternate_port_events_site.hostname
     request.META['SERVER_PORT'] = self.alternate_port_events_site.port
     self.assertEqual(Site.find_for_request(request), self.alternate_port_events_site)

    def get_context(self, request):
        context = super(ConferenceSubPage, self).get_context(request)
        current_site = Site.find_for_request(request)
        parent = self.get_parent_of_type('conference page')
        has_sidebar = parent.has_left_sidebar(context) or bool(main_reg)

        # Set social media fields dynamically and
        # get all the values from the parent page.
        # This doesn't seem like a good practice
        # How else can this be done?
        social_media_fields = [f.name for f in SocialMediaFields._meta.get_fields()]
        for field in social_media_fields:
            exec('self.' + field + ' = ' + 'parent.' + field)

        context['primary_branding_color'] = parent.primary_branding_color
        context['secondary_branding_color'] = parent.secondary_branding_color
        context['conference_logo'] = parent.conference_logo 
        context['conference_title'] = parent.title
        context['has_social_media'] = parent.has_social_media
        context['main_registration'] = parent.main_registration.all()
        context['sponsors'] = parent.sponsors.all()
        context['organizers'] = parent.organizers.all()
        context['secondary_registration'] = parent.sub_registration.all()
        context['secondary_registration_heading'] = parent.secondary_registration_heading
        context['secondary_registration_description'] = parent.secondary_registration_description
        context['home'] = parent.relative_url(current_site)
        return context

 def test_valid_headers_route_to_specific_site(self):
     # requests with a known Host: header should be directed to the specific site
     request = HttpRequest()
     request.path = '/'
     request.META['HTTP_HOST'] = self.events_site.hostname
     request.META['SERVER_PORT'] = self.events_site.port
     self.assertEqual(Site.find_for_request(request), self.events_site)

 def test_port_in_http_host_header_is_ignored(self):
     # port in the HTTP_HOST header is ignored
     request = HttpRequest()
     request.path = '/'
     request.META['HTTP_HOST'] = "%s:%s" % (self.events_site.hostname, self.events_site.port)
     request.META['SERVER_PORT'] = self.alternate_port_events_site.port
     self.assertEqual(Site.find_for_request(request), self.alternate_port_events_site)

 def test_unrecognised_port_and_default_host_routes_to_default_site(self):
     # requests to the default host on an unrecognised port should be directed to the default site
     request = HttpRequest()
     request.path = '/'
     request.META['HTTP_HOST'] = self.default_site.hostname
     request.META['SERVER_PORT'] = self.unrecognised_port
     self.assertEqual(Site.find_for_request(request), self.default_site)

 def test_unrecognised_port_on_known_hostname_routes_there_if_no_ambiguity(self):
     # requests on an unrecognised port should be directed to the site with
     # matching hostname if there is no ambiguity
     request = HttpRequest()
     request.path = '/'
     request.META['HTTP_HOST'] = self.about_site.hostname
     request.META['SERVER_PORT'] = self.unrecognised_port
     self.assertEqual(Site.find_for_request(request), self.about_site)

    def setUp(self):
        self.home_page = Page.objects.get(id=2)
        self.routable_page = self.home_page.add_child(instance=RoutablePageTest(title="Routable Page", live=True))

        self.rf = RequestFactory()
        self.request = self.rf.get(self.routable_page.url)
        self.request.site = Site.find_for_request(self.request)
        self.context = {"request": self.request}

 def test_unrecognised_port_on_known_hostname_routes_to_default_site_if_ambiguity(self):
     # requests on an unrecognised port should be directed to the default
     # site, even if their hostname (but not port) matches more than one
     # other entry
     request = HttpRequest()
     request.path = '/'
     request.META['HTTP_HOST'] = self.events_site.hostname
     request.META['SERVER_PORT'] = self.unrecognised_port
     self.assertEqual(Site.find_for_request(request), self.default_site)

    def test_tag(self):
        factory = RequestFactory()

        request = factory.get('/home/blog/tag/news/')
        request.site = Site.find_for_request(request)
        request.user = User.objects.create_user(username='test')

        response = self.bip.tag(request)
        self.assertEqual(200, response.status_code)

 def process_request(self, request):
     """
     Set request.site to contain the Site object responsible for handling this request,
     according to hostname matching rules
     """
     try:
         request.site = Site.find_for_request(request)
     except Site.DoesNotExist:
         request.site = None

 def item_enclosure_url(self, item):
     if not getattr(item.featured_image, 'file', None):
         url = item.featured_image
     else:
         url = item.featured_image.file.url
         url = "{0}://{1}{2}".format(
             "http" + ("s" if self.request.is_secure() else ""),
             Site.find_for_request(self.request).hostname,
             url
         )
     return url