Merge lp:~cjohnston/summit/clean-up-test-stuff into lp:summit

[Chris Johnston]

Adds URL/virt fields, cleans up some tests, pep8 fixes

[lp:~cjohnston/summit/clean-up-test-stuff]

482. By Chris Johnston on 2013-02-20

more cleanup

483. By Chris Johnston on 2013-02-20

fixes some tests

[Michael Hall (mhall119)]

Looks good, schedule and common tests all pass

review: Approve

=== modified file 'requirements.txt'
--- requirements.txt	2012-08-12 22:32:46 +0000
+++ requirements.txt	2013-02-20 17:36:21 +0000
@@ -6,7 +6,7 @@
 #       include patches applied by the package maintainers.
 #
 
-Django==1.3.1
+Django==1.3.2
 South==0.7.3
 bzr>=2.4b4
 distribute==0.6.10

=== modified file 'summit/schedule/admin/meetingadmin.py'
--- summit/schedule/admin/meetingadmin.py	2012-10-09 19:01:06 +0000
+++ summit/schedule/admin/meetingadmin.py	2013-02-20 17:36:21 +0000
@@ -132,23 +132,68 @@
 share.short_description = "Share Meetings (Private only)"
 
 class MeetingAdmin(admin.ModelAdmin):
-    list_display = ('summit', 'name', 'title', 'slots', 'override_break', 'private', 'requires_dial_in', 'video', 'type', 'approved')
+    list_display = (
+        'summit',
+        'name',
+        'title',
+        'slots',
+        'override_break',
+        'private',
+        'requires_dial_in',
+        'video',
+        'type',
+        'approved',
+        'virtual_meeting',
+    )
     list_display_links = ('name', 'title')
-    list_filter = ('summit', 'type', 'approved', 'tracks', 'slots', 'private',
-                   'status', 'priority')
+    list_filter = (
+        'summit',
+        'type',
+        'approved',
+        'tracks',
+        'slots',
+        'private',
+        'status',
+        'priority',
+        'virtual_meeting',
+    )
     search_fields = ('name', 'title')
 
     fieldsets = (
         (None, {
-            'fields': ('summit', 'name', 'title', 'description', 'approved',
-                       'type', 'tracks', 'requires_dial_in', 'video'),
+            'fields': (
+                'summit',
+                'name',
+                'title',
+                'description',
+                'virtual_meeting',
+                'approved',
+                'type',
+                'tracks',
+                'requires_dial_in',
+                'video',
+            ),
+        }),
+        ("Hangout details", {
+            'fields': ('hangout_url', 'broadcast_url',)
         }),
         ("References", {
-            'fields': ('spec_url', 'launchpad_blueprint_id', 'wiki_url', 'pad_url'),
+            'fields': (
+                'spec_url',
+                'launchpad_blueprint_id',
+                'wiki_url',
+                'pad_url'),
         }),
         ("Scheduling details", {
             'classes': ('collapse', ),
-            'fields': ('slots', 'override_break', 'private', 'private_key', 'status', 'priority')
+            'fields': (
+                'slots',
+                'override_break',
+                'private',
+                'private_key',
+                'status',
+                'priority'
+            )
         }),
         ("Key people", {
             'classes': ('collapse', ),

=== added file 'summit/schedule/migrations/0026_add_virtual_sprint_checkbox.py'
--- summit/schedule/migrations/0026_add_virtual_sprint_checkbox.py	1970-01-01 00:00:00 +0000
+++ summit/schedule/migrations/0026_add_virtual_sprint_checkbox.py	2013-02-20 17:36:21 +0000
@@ -0,0 +1,215 @@
+# encoding: utf-8
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        
+        # Adding field 'Meeting.virtual_meeting'
+        db.add_column('schedule_meeting', 'virtual_meeting', self.gf('django.db.models.fields.BooleanField')(default=False), keep_default=False)
+
+        # Adding field 'Summit.virtual_summit'
+        db.add_column('schedule_summit', 'virtual_summit', self.gf('django.db.models.fields.BooleanField')(default=False), keep_default=False)
+
+
+    def backwards(self, orm):
+        
+        # Deleting field 'Meeting.virtual_meeting'
+        db.delete_column('schedule_meeting', 'virtual_meeting')
+
+        # Deleting field 'Summit.virtual_summit'
+        db.delete_column('schedule_summit', 'virtual_summit')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'ordering': "['username']", 'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'schedule.agenda': {
+            'Meta': {'ordering': "('slot', 'room')", 'unique_together': "(('slot', 'room'),)", 'object_name': 'Agenda'},
+            'auto': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'meeting': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Meeting']"}),
+            'room': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Room']"}),
+            'slot': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Slot']"})
+        },
+        'schedule.attendee': {
+            'Meta': {'ordering': "('user__username', 'summit')", 'object_name': 'Attendee'},
+            'crew': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_column': "'crew'"}),
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'secret_key_id': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'tracks': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Track']", 'symmetrical': 'False', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'schedule.attendeebusy': {
+            'Meta': {'ordering': "('attendee', 'start_utc', 'end_utc')", 'object_name': 'AttendeeBusy'},
+            'attendee': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'busy_set'", 'to': "orm['schedule.Attendee']"}),
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"})
+        },
+        'schedule.crew': {
+            'Meta': {'ordering': "('date_utc', 'attendee')", 'object_name': 'Crew'},
+            'attendee': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'crew_schedule'", 'to': "orm['schedule.Attendee']"}),
+            'date_utc': ('django.db.models.fields.DateField', [], {'db_column': "'date'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'schedule.lead': {
+            'Meta': {'ordering': "('summit', 'track')", 'object_name': 'Lead'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'lead': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'lead'", 'to': "orm['schedule.Attendee']"}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'track': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Track']"})
+        },
+        'schedule.meeting': {
+            'Meta': {'object_name': 'Meeting'},
+            'approved': ('django.db.models.fields.CharField', [], {'default': "'PENDING'", 'max_length': '10', 'null': 'True'}),
+            'approver': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'approver_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'assignee': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'assignee_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'description': ('django.db.models.fields.TextField', [], {'max_length': '2047', 'blank': 'True'}),
+            'drafter': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'drafter_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'launchpad_blueprint_id': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'name': ('summit.schedule.fields.NameField', [], {'max_length': '100'}),
+            'override_break': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'pad_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
+            'participants': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Attendee']", 'symmetrical': 'False', 'through': "orm['schedule.Participant']", 'blank': 'True'}),
+            'priority': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'private': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'private_key': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),
+            'requires_dial_in': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'scribe': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'scribe_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'slots': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
+            'spec_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
+            'status': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'tracks': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Track']", 'symmetrical': 'False', 'blank': 'True'}),
+            'type': ('django.db.models.fields.CharField', [], {'default': "u'discussion'", 'max_length': '15'}),
+            'video': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'virtual_meeting': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'wiki_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'})
+        },
+        'schedule.participant': {
+            'Meta': {'ordering': "('meeting', 'attendee', 'participation')", 'object_name': 'Participant'},
+            'attendee': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Attendee']"}),
+            'from_launchpad': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'meeting': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Meeting']"}),
+            'participation': ('django.db.models.fields.CharField', [], {'default': "'ATTENDING'", 'max_length': '32', 'null': 'True'})
+        },
+        'schedule.room': {
+            'Meta': {'ordering': "('summit', 'name')", 'object_name': 'Room'},
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_column': "'end'", 'blank': 'True'}),
+            'has_dial_in': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'icecast_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'irc_channel': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
+            'name': ('summit.schedule.fields.NameField', [], {'max_length': '50'}),
+            'size': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_column': "'start'", 'blank': 'True'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'tracks': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Track']", 'symmetrical': 'False', 'blank': 'True'}),
+            'type': ('django.db.models.fields.CharField', [], {'default': "u'open'", 'max_length': '7'})
+        },
+        'schedule.roombusy': {
+            'Meta': {'ordering': "('room', 'start_utc', 'end_utc')", 'object_name': 'RoomBusy'},
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'room': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'busy_set'", 'to': "orm['schedule.Room']"}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"})
+        },
+        'schedule.slot': {
+            'Meta': {'ordering': "('summit', 'start_utc', 'end_utc')", 'object_name': 'Slot'},
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'type': ('django.db.models.fields.CharField', [], {'default': "u'open'", 'max_length': '7'})
+        },
+        'schedule.summit': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'Summit'},
+            'date_end': ('django.db.models.fields.DateField', [], {'null': 'True'}),
+            'date_start': ('django.db.models.fields.DateField', [], {'null': 'True'}),
+            'description': ('django.db.models.fields.TextField', [], {'max_length': '2047', 'blank': 'True'}),
+            'etherpad': ('django.db.models.fields.URLField', [], {'default': "'http://pad.ubuntu.com/'", 'max_length': '75'}),
+            'hashtag': ('django.db.models.fields.CharField', [], {'max_length': '25', 'blank': 'True'}),
+            'help_text': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_update': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'location': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'managers': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'managers'", 'blank': 'True', 'to': "orm['auth.User']"}),
+            'name': ('summit.schedule.fields.NameField', [], {'max_length': '50'}),
+            'qr': ('django.db.models.fields.URLField', [], {'default': "''", 'max_length': '100', 'blank': 'True'}),
+            'schedulers': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'schedulers'", 'blank': 'True', 'to': "orm['auth.User']"}),
+            'sites': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['sites.Site']", 'symmetrical': 'False'}),
+            'state': ('django.db.models.fields.CharField', [], {'default': "u'sponsor'", 'max_length': '10'}),
+            'timezone': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'virtual_summit': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
+        },
+        'schedule.summitsprint': {
+            'Meta': {'ordering': "('summit', 'import_url')", 'object_name': 'SummitSprint'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'import_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'sprint_set'", 'to': "orm['schedule.Summit']"})
+        },
+        'schedule.track': {
+            'Meta': {'ordering': "('summit', 'title', 'slug')", 'object_name': 'Track'},
+            'allow_adjacent_sessions': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'color': ('django.db.models.fields.CharField', [], {'default': "'FFFFFF'", 'max_length': '6'}),
+            'description': ('django.db.models.fields.TextField', [], {'max_length': '1000', 'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'slug': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'sites.site': {
+            'Meta': {'ordering': "('domain',)", 'object_name': 'Site', 'db_table': "'django_site'"},
+            'domain': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        }
+    }
+
+    complete_apps = ['schedule']

=== added file 'summit/schedule/migrations/0027_add_hangout_urls.py'
--- summit/schedule/migrations/0027_add_hangout_urls.py	1970-01-01 00:00:00 +0000
+++ summit/schedule/migrations/0027_add_hangout_urls.py	2013-02-20 17:36:21 +0000
@@ -0,0 +1,217 @@
+# encoding: utf-8
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        
+        # Adding field 'Meeting.hangout_url'
+        db.add_column('schedule_meeting', 'hangout_url', self.gf('django.db.models.fields.URLField')(max_length=200, null=True, blank=True), keep_default=False)
+
+        # Adding field 'Meeting.broadcast_url'
+        db.add_column('schedule_meeting', 'broadcast_url', self.gf('django.db.models.fields.URLField')(max_length=200, null=True, blank=True), keep_default=False)
+
+
+    def backwards(self, orm):
+        
+        # Deleting field 'Meeting.hangout_url'
+        db.delete_column('schedule_meeting', 'hangout_url')
+
+        # Deleting field 'Meeting.broadcast_url'
+        db.delete_column('schedule_meeting', 'broadcast_url')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'ordering': "['username']", 'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'schedule.agenda': {
+            'Meta': {'ordering': "('slot', 'room')", 'unique_together': "(('slot', 'room'),)", 'object_name': 'Agenda'},
+            'auto': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'meeting': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Meeting']"}),
+            'room': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Room']"}),
+            'slot': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Slot']"})
+        },
+        'schedule.attendee': {
+            'Meta': {'ordering': "('user__username', 'summit')", 'object_name': 'Attendee'},
+            'crew': ('django.db.models.fields.BooleanField', [], {'default': 'False', 'db_column': "'crew'"}),
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'secret_key_id': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'tracks': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Track']", 'symmetrical': 'False', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'schedule.attendeebusy': {
+            'Meta': {'ordering': "('attendee', 'start_utc', 'end_utc')", 'object_name': 'AttendeeBusy'},
+            'attendee': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'busy_set'", 'to': "orm['schedule.Attendee']"}),
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"})
+        },
+        'schedule.crew': {
+            'Meta': {'ordering': "('date_utc', 'attendee')", 'object_name': 'Crew'},
+            'attendee': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'crew_schedule'", 'to': "orm['schedule.Attendee']"}),
+            'date_utc': ('django.db.models.fields.DateField', [], {'db_column': "'date'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'schedule.lead': {
+            'Meta': {'ordering': "('summit', 'track')", 'object_name': 'Lead'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'lead': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'lead'", 'to': "orm['schedule.Attendee']"}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'track': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Track']"})
+        },
+        'schedule.meeting': {
+            'Meta': {'object_name': 'Meeting'},
+            'approved': ('django.db.models.fields.CharField', [], {'default': "'PENDING'", 'max_length': '10', 'null': 'True'}),
+            'approver': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'approver_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'assignee': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'assignee_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'broadcast_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
+            'description': ('django.db.models.fields.TextField', [], {'max_length': '2047', 'blank': 'True'}),
+            'drafter': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'drafter_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'hangout_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'launchpad_blueprint_id': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'name': ('summit.schedule.fields.NameField', [], {'max_length': '100'}),
+            'override_break': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'pad_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'null': 'True', 'blank': 'True'}),
+            'participants': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Attendee']", 'symmetrical': 'False', 'through': "orm['schedule.Participant']", 'blank': 'True'}),
+            'priority': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'private': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'private_key': ('django.db.models.fields.CharField', [], {'max_length': '32', 'null': 'True', 'blank': 'True'}),
+            'requires_dial_in': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'scribe': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'scribe_set'", 'null': 'True', 'to': "orm['schedule.Attendee']"}),
+            'slots': ('django.db.models.fields.IntegerField', [], {'default': '1'}),
+            'spec_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
+            'status': ('django.db.models.fields.CharField', [], {'max_length': '10', 'null': 'True', 'blank': 'True'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'tracks': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Track']", 'symmetrical': 'False', 'blank': 'True'}),
+            'type': ('django.db.models.fields.CharField', [], {'default': "u'discussion'", 'max_length': '15'}),
+            'video': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'virtual_meeting': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'wiki_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'})
+        },
+        'schedule.participant': {
+            'Meta': {'ordering': "('meeting', 'attendee', 'participation')", 'object_name': 'Participant'},
+            'attendee': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Attendee']"}),
+            'from_launchpad': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'meeting': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Meeting']"}),
+            'participation': ('django.db.models.fields.CharField', [], {'default': "'ATTENDING'", 'max_length': '32', 'null': 'True'})
+        },
+        'schedule.room': {
+            'Meta': {'ordering': "('summit', 'name')", 'object_name': 'Room'},
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_column': "'end'", 'blank': 'True'}),
+            'has_dial_in': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'icecast_url': ('django.db.models.fields.URLField', [], {'max_length': '200', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'irc_channel': ('django.db.models.fields.CharField', [], {'max_length': '50', 'blank': 'True'}),
+            'name': ('summit.schedule.fields.NameField', [], {'max_length': '50'}),
+            'size': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'db_column': "'start'", 'blank': 'True'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'tracks': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['schedule.Track']", 'symmetrical': 'False', 'blank': 'True'}),
+            'type': ('django.db.models.fields.CharField', [], {'default': "u'open'", 'max_length': '7'})
+        },
+        'schedule.roombusy': {
+            'Meta': {'ordering': "('room', 'start_utc', 'end_utc')", 'object_name': 'RoomBusy'},
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'room': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'busy_set'", 'to': "orm['schedule.Room']"}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"})
+        },
+        'schedule.slot': {
+            'Meta': {'ordering': "('summit', 'start_utc', 'end_utc')", 'object_name': 'Slot'},
+            'end_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'end'"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'start_utc': ('django.db.models.fields.DateTimeField', [], {'db_column': "'start'"}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'type': ('django.db.models.fields.CharField', [], {'default': "u'open'", 'max_length': '7'})
+        },
+        'schedule.summit': {
+            'Meta': {'ordering': "('name',)", 'object_name': 'Summit'},
+            'date_end': ('django.db.models.fields.DateField', [], {'null': 'True'}),
+            'date_start': ('django.db.models.fields.DateField', [], {'null': 'True'}),
+            'description': ('django.db.models.fields.TextField', [], {'max_length': '2047', 'blank': 'True'}),
+            'etherpad': ('django.db.models.fields.URLField', [], {'default': "'http://pad.ubuntu.com/'", 'max_length': '75'}),
+            'hashtag': ('django.db.models.fields.CharField', [], {'max_length': '25', 'blank': 'True'}),
+            'help_text': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_update': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'location': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'managers': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'managers'", 'blank': 'True', 'to': "orm['auth.User']"}),
+            'name': ('summit.schedule.fields.NameField', [], {'max_length': '50'}),
+            'qr': ('django.db.models.fields.URLField', [], {'default': "''", 'max_length': '100', 'blank': 'True'}),
+            'schedulers': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'schedulers'", 'blank': 'True', 'to': "orm['auth.User']"}),
+            'sites': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['sites.Site']", 'symmetrical': 'False'}),
+            'state': ('django.db.models.fields.CharField', [], {'default': "u'sponsor'", 'max_length': '10'}),
+            'timezone': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'virtual_summit': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
+        },
+        'schedule.summitsprint': {
+            'Meta': {'ordering': "('summit', 'import_url')", 'object_name': 'SummitSprint'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'import_url': ('django.db.models.fields.URLField', [], {'max_length': '200'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'sprint_set'", 'to': "orm['schedule.Summit']"})
+        },
+        'schedule.track': {
+            'Meta': {'ordering': "('summit', 'title', 'slug')", 'object_name': 'Track'},
+            'allow_adjacent_sessions': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'color': ('django.db.models.fields.CharField', [], {'default': "'FFFFFF'", 'max_length': '6'}),
+            'description': ('django.db.models.fields.TextField', [], {'max_length': '1000', 'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'slug': ('django.db.models.fields.CharField', [], {'max_length': '100', 'null': 'True'}),
+            'summit': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['schedule.Summit']"}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'sites.site': {
+            'Meta': {'ordering': "('domain',)", 'object_name': 'Site', 'db_table': "'django_site'"},
+            'domain': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        }
+    }
+
+    complete_apps = ['schedule']

=== modified file 'summit/schedule/models/meetingmodel.py'
--- summit/schedule/models/meetingmodel.py	2012-10-09 21:00:53 +0000
+++ summit/schedule/models/meetingmodel.py	2013-02-20 17:36:21 +0000
@@ -100,6 +100,16 @@
                               null=True, blank=True)
     priority = models.IntegerField(choices=PRIORITY_CHOICES,
                                    null=True, blank=True)
+    hangout_url = models.URLField(
+        blank=True,
+        null=True,
+        help_text="URL for participation essential users to join the hangout",
+    )
+    broadcast_url = models.URLField(
+        blank=True,
+        null=True,
+        help_text="URL for all other participants to watch the hangout",
+    )
     # FIXME tracks must be for the same summit
     # (will require js magic in admin to refresh the boxes)
     tracks = models.ManyToManyField(Track, blank=True)
@@ -112,14 +122,24 @@
     slots = models.IntegerField(default=1)
     override_break = models.BooleanField(default=False, verbose_name="Override Break",
                               help_text="If this is a multi-slot meeting, should it be allowed to take place during a break")
+    virtual_meeting = models.BooleanField(
+        help_text="If virtual summit is true, this will not override it"
+    )
     approved = models.CharField(max_length=10, choices=REVIEW_CHOICES,
                               null=True, default='PENDING')
     private = models.BooleanField(default=False)
     private_key = models.CharField(max_length=32, null=True, blank=True)
 
-    requires_dial_in = models.BooleanField(verbose_name="This session requires dial in capabilities", default=False)
-    video = models.BooleanField(verbose_name="This session is to be videotaped", default=False)
-    
+    requires_dial_in = models.BooleanField(
+        verbose_name="Dial in",
+        help_text="This session requires dial in availability"
+    )
+    video = models.BooleanField(
+        verbose_name="Video recording",
+        help_text="This session is to be videotaped",
+        default=False
+    )
+
     # FIXME attendees must be for the same summit
     # (will require js magic in admin to refresh the boxes)
     drafter = models.ForeignKey(Attendee, null=True, blank=True,
@@ -214,7 +234,7 @@
         if self.type in self.TYPE_ICONS:
             return self.TYPE_ICONS[self.type]
     icon = property(get_meeting_type_icon)
-    
+
     def __unicode__(self):
         if self.name:
             return self.name
@@ -232,7 +252,7 @@
     def spec_priority(self):
         label = dict(self.PRIORITY_CHOICES)[self.priority]
         icon = label.lower()
-        
+
     def can_edit_pm(self, attendee):
         if attendee is not None:
             if attendee.user == self.approver or attendee.user == self.drafter or attendee.user == self.assignee or self.summit.is_scheduler(attendee):
@@ -260,12 +280,12 @@
                 return False
         else:
             return False
-        
+
     def is_tracklead(self, attendee):
         if attendee is not None:
             return self.tracks.filter(lead__lead=attendee).exists()
         return False
-        
+
     @property
     def attendees(self):
         attendees = []
@@ -308,7 +328,7 @@
         attendees = set()
         for participant in self.participant_set.all():
             if participant.participation == level:
-                attendees.add(participant.attendee)        
+                attendees.add(participant.attendee)
         return attendees
 
     def update_from_launchpad(self, elem):
@@ -316,7 +336,7 @@
 
         if not self.approved == 'REMOVED':
             self.approved = 'APPROVED'
-        
+
         name = elem.get("name")
         if name:
             self.name = name[:100]
@@ -453,7 +473,7 @@
             if this_slot.type == 'plenary' and self.type not in ('plenary', 'talk', 'special'):
                 raise Meeting.SchedulingError(
                     "Not a plenary event, talk or special event")
-            
+
             # Check that the room is not already in use
             try:
                 existing = room.agenda_set.get(slot=this_slot)

=== modified file 'summit/schedule/models/summitmodel.py'
--- summit/schedule/models/summitmodel.py	2013-01-18 23:06:46 +0000
+++ summit/schedule/models/summitmodel.py	2013-02-20 17:36:21 +0000
@@ -60,7 +60,7 @@
 User.__unicode__ = unicode_user
 
 class SummitManager(CurrentSiteManager):
-    
+
     def next(self):
         try:
             return self.order_by('-date_start')[0]
@@ -93,12 +93,14 @@
     date_end = models.DateField(blank=False, null=True)
     managers = models.ManyToManyField(User, blank=True, related_name='managers')
     schedulers = models.ManyToManyField(User, blank=True, related_name='schedulers')
-
+    virtual_summit = models.BooleanField(
+        help_text="Check this if the entire sprint is virtual"
+    )
     help_text = models.TextField(null=True, blank=True, help_text='Summit specific instructions and links for getting help during the event')
-    
+
     objects = models.Manager()
     on_site = SummitManager()
-    
+
     class Meta:
         app_label = 'schedule'
         ordering = ('name', )
@@ -108,7 +110,7 @@
 
     def get_absolute_url(self):
         return getattr(settings, 'SITE_ROOT', 'http://summit.ubuntu.com') + reverse('summit.schedule.views.summit', args=(self.name,))
-        
+
     def localize(self, datetime):
         """Convert a datetime to the summit-local timezone.
 
@@ -171,7 +173,7 @@
 
     def ical_url(self):
         return getattr(settings, 'SITE_ROOT', 'http://summit.ubuntu.com') + reverse('summit.schedule.views.ical', args=(self.name,))
-        
+
     def public_rooms(self):
         """List of public rooms for this summit.
 
@@ -212,7 +214,7 @@
 
     def private_rooms(self):
         """List fo private rooms for this summit."""
-        
+
         def by_title(a, b):
             if a.track is None:
                 return 1
@@ -289,7 +291,7 @@
 
     def update_attendee_from_launchpad(self, elem, options={}):
         """Update or create single attendee from Launchpad data."""
-        
+
         username = elem.get("name", "")
         if not username:
             return
@@ -372,19 +374,29 @@
         """Delete any automatically created agenda items that have problems."""
         today = datetime.now()
         for meeting in self.meeting_set.all():
-            for agenda in meeting.agenda_set.filter(auto=True, slot__start_utc__gt=today):
+            for agenda in meeting.agenda_set.filter(
+                auto=True,
+                slot__start_utc__gt=today
+            ):
                 try:
                     missing = meeting.check_schedule(agenda.slot, agenda.room)
                     if len(missing):
-                        print "Warning: required people not available: %s (%s) at %s in %s: %s" % (
-                            meeting, meeting.drafter, agenda.slot, agenda.room,
-                            ', '.join(m.user.username for m in missing))
+                        print "Warning: required people not available:"
+                        print "%s (%s) at %s in %s: %s" % (
+                            meeting,
+                            meeting.drafter,
+                            agenda.slot,
+                            agenda.room,
+                            ', '.join(m.user.username for m in missing)
+                        )
                         agenda.delete()
                 except meeting.SchedulingError, e:
-                    print "Error: %s at %s in %s: %s" % (meeting,
-                                                         agenda.slot,
-                                                         agenda.room,
-                                                         e)
+                    print "Error: %s at %s in %s: %s" % (
+                        meeting,
+                        agenda.slot,
+                        agenda.room,
+                        e
+                    )
                     agenda.delete()
 
     def can_change_agenda(self, attendee):

=== modified file 'summit/schedule/tests.py'
--- summit/schedule/tests.py	2012-10-27 14:59:34 +0000
+++ summit/schedule/tests.py	2013-02-20 17:36:21 +0000
@@ -34,17 +34,19 @@
 from model_mommy import mommy as factory
 from summit.schedule.fields import NameField
 
-from summit.schedule.models import (Summit,
-                                    Slot,
-                                    Attendee,
-                                    Meeting,
-                                    Track,
-                                    Room,
-                                    Agenda,
-                                    Participant,
-                                    SummitSprint,
-                                    Lead)
-                                    
+from summit.schedule.models import (
+    Summit,
+    Slot,
+    Attendee,
+    Meeting,
+    Track,
+    Room,
+    Agenda,
+    Participant,
+    SummitSprint,
+    Lead,
+)
+
 from summit.schedule.render import Schedule
 from summit.common import launchpad
 
@@ -56,6 +58,7 @@
 site_root = getattr(settings, 'SITE_ROOT', 'http://summit.ubuntu.com')
 theme_media = getattr(settings, 'THEME_MEDIA', 'ubuntu_website.MEDIA_ROOT')
 
+
 class RequestFactory(djangotest.Client):
     """
     Class that lets you create mock Request objects for use in testing.
@@ -69,7 +72,7 @@
     This class re-uses the django.test.client.Client interface, docs here:
     http://www.djangoproject.com/documentation/testing/#the-test-client
 
-    Once you have a request object you can pass it to any view function, 
+    Once you have a request object you can pass it to any view function,
     just as if that view had been hooked up using a URLconf.
 
     """
@@ -96,8 +99,11 @@
         handler.load_middleware()
         for middleware_method in handler._request_middleware:
             if middleware_method(request):
-                raise Exception("Couldn't create request mock object - "
-                                "request middleware %s returned a response" % middleware_method)
+                raise Exception(
+                    "Couldn't create request mock object - "
+                    "request middleware %s returned a response"
+                    % middleware_method
+                )
         return request
 
 
@@ -122,7 +128,11 @@
             type='closed')
 
         agenda = factory.make_one(Agenda, slot=slot)
-        meeting = factory.make_one(Meeting, requires_dial_in=False, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            private=False
+        )
 
         # XXX check_schedule should only be checking the schedule, not
         # checking and modifying the schedule.
@@ -142,20 +152,44 @@
         room1 = factory.make_one(Room)
         room2 = factory.make_one(Room)
 
-        meeting1 = factory.make_one(Meeting, summit=slot.summit, requires_dial_in=False, private=False)
-        meeting2 = factory.make_one(Meeting, summit=slot.summit, requires_dial_in=False, private=False)
+        meeting1 = factory.make_one(
+            Meeting,
+            summit=slot.summit,
+            requires_dial_in=False,
+            private=False
+        )
+        meeting2 = factory.make_one(
+            Meeting,
+            summit=slot.summit,
+            requires_dial_in=False,
+            private=False
+        )
 
         attendee = factory.make_one(Attendee)
-        factory.make_one(Participant, meeting=meeting1, attendee=attendee, participation = 'REQUIRED')
-        factory.make_one(Participant, meeting=meeting2, attendee=attendee, participation = 'REQUIRED')
+        factory.make_one(
+            Participant,
+            meeting=meeting1,
+            attendee=attendee,
+            participation='REQUIRED'
+        )
+        factory.make_one(
+            Participant,
+            meeting=meeting2,
+            attendee=attendee,
+            participation='REQUIRED'
+        )
 
         factory.make_one(Agenda, meeting=meeting1, slot=slot, room=room1)
-        agenda = factory.make_one(Agenda, meeting=meeting2, slot=slot, room=room2)
+        agenda = factory.make_one(
+            Agenda,
+            meeting=meeting2,
+            slot=slot,
+            room=room2
+        )
 
         missing = meeting2.check_schedule(agenda.slot, agenda.room)
         self.assertEqual([attendee.name], [a.name for a in missing])
 
-
     def make_open_slot(self):
         now = datetime.datetime.utcnow()
         one_hour = datetime.timedelta(0, 3600)
@@ -168,8 +202,19 @@
 
     def test_check_schedule_errors_on_no_dial_in(self):
         slot = self.make_open_slot()
-        room = factory.make_one(Room, has_dial_in=False, summit=slot.summit, name="testroom")
-        meeting = factory.make_one(Meeting, requires_dial_in=True, summit=slot.summit, name="testmeeting", private=False)
+        room = factory.make_one(
+            Room,
+            has_dial_in=False,
+            summit=slot.summit,
+            name="testroom"
+        )
+        meeting = factory.make_one(
+            Meeting,
+            requires_dial_in=True,
+            summit=slot.summit,
+            name="testmeeting",
+            private=False
+        )
         try:
             meeting.check_schedule(slot, room)
         except meeting.SchedulingError, e:
@@ -185,26 +230,51 @@
             Slot,
             start_utc=now+one_hour,
             end_utc=now+one_hour+one_hour,
-            type='open', summit=summit)
+            type='open', summit=summit
+        )
         slot2 = factory.make_one(
             Slot,
             start_utc=now+one_hour+one_hour,
             end_utc=now+one_hour+one_hour+one_hour,
-            type='open', summit=summit)
+            type='open', summit=summit
+        )
         return slot1, slot2
 
     def test_check_schedule_errors_on_same_track_in_previous_slot(self):
         slot1, slot2 = self.make_two_adjacent_slots()
-        room = factory.make_one(Room, summit=slot1.summit,
-                name="testroom")
-        track = factory.make_one(Track, summit=slot1.summit,
-                title="testtrack", allow_adjacent_sessions=False)
-        track2 = factory.make_one(Track, summit=slot1.summit,
-                title="adjacenttrack", allow_adjacent_sessions=True)
-        meeting1 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting1", type='blueprint', private=False)
-        meeting2 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting2", type='blueprint', private=False)
+        room = factory.make_one(
+            Room,
+            summit=slot1.summit,
+            name="testroom"
+        )
+        track = factory.make_one(
+            Track,
+            summit=slot1.summit,
+            title="testtrack",
+            allow_adjacent_sessions=False
+        )
+        track2 = factory.make_one(
+            Track,
+            summit=slot1.summit,
+            title="adjacenttrack",
+            allow_adjacent_sessions=True
+        )
+        meeting1 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting1",
+            type='blueprint',
+            private=False
+        )
+        meeting2 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting2",
+            type='blueprint',
+            private=False
+        )
         meeting1.tracks = [track, track2]
         meeting2.tracks = [track]
         meeting1.agenda_set.create(room=room, slot=slot1)
@@ -217,14 +287,29 @@
 
     def test_check_schedule_errors_on_same_track_in_next_slot(self):
         slot1, slot2 = self.make_two_adjacent_slots()
-        room = factory.make_one(Room, summit=slot1.summit,
-                name="testroom")
-        track = factory.make_one(Track, summit=slot1.summit,
-                title="testtrack", allow_adjacent_sessions=False)
-        meeting1 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting1", type='blueprint', private=False)
-        meeting2 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting2", type='blueprint', private=False)
+        room = factory.make_one(Room, summit=slot1.summit, name="testroom")
+        track = factory.make_one(
+            Track,
+            summit=slot1.summit,
+            title="testtrack",
+            allow_adjacent_sessions=False
+        )
+        meeting1 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting1",
+            type='blueprint',
+            private=False
+        )
+        meeting2 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting2",
+            type='blueprint',
+            private=False
+        )
         meeting1.tracks = [track]
         meeting2.tracks = [track]
         meeting1.agenda_set.create(room=room, slot=slot2)
@@ -237,16 +322,35 @@
 
     def test_check_schedule_no_error_on_different_track(self):
         slot1, slot2 = self.make_two_adjacent_slots()
-        room = factory.make_one(Room, summit=slot1.summit,
-                name="testroom")
-        track = factory.make_one(Track, summit=slot1.summit,
-                title="testtrack", allow_adjacent_sessions=False)
-        other_track = factory.make_one(Track, summit=slot1.summit,
-                title="othertesttrack", allow_adjacent_sessions=False)
-        meeting1 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting1", type='blueprint', private=False)
-        meeting2 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting2", type='blueprint', private=False)
+        room = factory.make_one(Room, summit=slot1.summit, name="testroom")
+        track = factory.make_one(
+            Track,
+            summit=slot1.summit,
+            title="testtrack",
+            allow_adjacent_sessions=False
+        )
+        other_track = factory.make_one(
+            Track,
+            summit=slot1.summit,
+            title="othertesttrack",
+            allow_adjacent_sessions=False
+        )
+        meeting1 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting1",
+            type='blueprint',
+            private=False
+        )
+        meeting2 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting2",
+            type='blueprint',
+            private=False
+        )
         meeting1.tracks = [track]
         meeting2.tracks = [other_track]
         meeting1.agenda_set.create(room=room, slot=slot2)
@@ -254,14 +358,29 @@
 
     def test_check_schedule_no_error_on_same_track_for_plenaries(self):
         slot1, slot2 = self.make_two_adjacent_slots()
-        room = factory.make_one(Room, summit=slot1.summit,
-                name="testroom")
-        track = factory.make_one(Track, summit=slot1.summit,
-                title="testtrack", allow_adjacent_sessions=False)
-        meeting1 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting1", type='blueprint', private=False)
-        meeting2 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting2", type='plenary', private=False)
+        room = factory.make_one(Room, summit=slot1.summit, name="testroom")
+        track = factory.make_one(
+            Track,
+            summit=slot1.summit,
+            title="testtrack",
+            allow_adjacent_sessions=False
+        )
+        meeting1 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting1",
+            type='blueprint',
+            private=False
+        )
+        meeting2 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting2",
+            type='plenary',
+            private=False
+        )
         meeting1.tracks = [track]
         meeting2.tracks = [track]
         meeting1.agenda_set.create(room=room, slot=slot2)
@@ -269,14 +388,29 @@
 
     def test_check_schedule_no_error_on_same_track_for_ajdacent_sessions_allowed(self):
         slot1, slot2 = self.make_two_adjacent_slots()
-        room = factory.make_one(Room, summit=slot1.summit,
-                name="testroom")
-        track = factory.make_one(Track, summit=slot1.summit,
-                title="adjacenttrack", allow_adjacent_sessions=True)
-        meeting1 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting1", type='blueprint', private=False)
-        meeting2 = factory.make_one(Meeting, requires_dial_in=False,
-                summit=slot1.summit, name="testmeeting2", type='blueprint', private=False)
+        room = factory.make_one(Room, summit=slot1.summit, name="testroom")
+        track = factory.make_one(
+            Track,
+            summit=slot1.summit,
+            title="adjacenttrack",
+            allow_adjacent_sessions=True
+        )
+        meeting1 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting1",
+            type='blueprint',
+            private=False
+        )
+        meeting2 = factory.make_one(
+            Meeting,
+            requires_dial_in=False,
+            summit=slot1.summit,
+            name="testmeeting2",
+            type='blueprint',
+            private=False
+        )
         meeting1.tracks = [track]
         meeting2.tracks = [track]
         meeting1.agenda_set.create(room=room, slot=slot2)
@@ -284,16 +418,38 @@
 
     def test_try_schedule_into_refuses_room_without_dial_in(self):
         slot = self.make_open_slot()
-        room = factory.make_one(Room, has_dial_in=False, summit=slot.summit, name="testroom")
-        meeting = factory.make_one(Meeting, requires_dial_in=True, summit=slot.summit, name="testmeeting", private=False)
+        room = factory.make_one(
+            Room,
+            has_dial_in=False,
+            summit=slot.summit,
+            name="testroom"
+        )
+        meeting = factory.make_one(
+            Meeting,
+            requires_dial_in=True,
+            summit=slot.summit,
+            name="testmeeting",
+            private=False
+        )
 
         self.assertEqual(False, meeting.try_schedule_into([room]))
         self.assertEqual(0, meeting.agenda_set.all().count())
 
     def test_try_schedule_into_allows_room_with_dial_in(self):
         slot = self.make_open_slot()
-        room = factory.make_one(Room, has_dial_in=True, summit=slot.summit, name="testroom")
-        meeting = factory.make_one(Meeting, requires_dial_in=True, summit=slot.summit, name="testmeeting", private=False)
+        room = factory.make_one(
+            Room,
+            has_dial_in=True,
+            summit=slot.summit,
+            name="testroom"
+        )
+        meeting = factory.make_one(
+            Meeting,
+            requires_dial_in=True,
+            summit=slot.summit,
+            name="testmeeting",
+            private=False
+        )
 
         self.assertEqual(True, meeting.try_schedule_into([room]))
         self.assertEqual(1, meeting.agenda_set.all().count())
@@ -312,8 +468,13 @@
         summit_name = 'testsummit'
         summit = factory.make_one(Summit, name=summit_name)
         name = 'testmeeting'
-        meeting = factory.make_one(Meeting, pad_url=None, name=name,
-                summit=summit, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name=name,
+            summit=summit,
+            private=False
+        )
         pad_host = self.get_pad_host()
         url = pad_host + summit_name + '-' + name
         self.assertEqual(url, meeting.link_to_pad)
@@ -322,8 +483,13 @@
         summit_name = 'testsummit'
         summit = factory.make_one(Summit, name=summit_name)
         name = 'test+meeting'
-        meeting = factory.make_one(Meeting, pad_url=None, name=name,
-                summit=summit, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name=name,
+            summit=summit,
+            private=False
+        )
         pad_host = self.get_pad_host()
         url = pad_host + summit_name + '-' + name.replace("+", "-")
         self.assertEqual(url, meeting.link_to_pad)
@@ -337,8 +503,13 @@
         summit_name = 'testsummit'
         summit = factory.make_one(Summit, name=summit_name)
         name = 'testmeeting'
-        meeting = factory.make_one(Meeting, pad_url=None, name=name,
-                summit=summit, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name=name,
+            summit=summit,
+            private=False
+        )
         pad_host = self.get_pad_host()
         url = pad_host + "ep/pad/view/" + summit_name + '-' + name + "/latest"
         self.assertEqual(url, meeting.edit_link_to_pad)
@@ -347,53 +518,120 @@
         summit_name = 'testsummit'
         summit = factory.make_one(Summit, name=summit_name)
         name = 'test+meeting'
-        meeting = factory.make_one(Meeting, pad_url=None, name=name,
-                summit=summit, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name=name,
+            summit=summit,
+            private=False
+        )
         pad_host = self.get_pad_host()
-        url = (pad_host + "ep/pad/view/" + summit_name
-                + '-' + name.replace("+", "-") + "/latest")
+        url = (
+            pad_host
+            + "ep/pad/view/"
+            + summit_name
+            + '-'
+            + name.replace("+", "-")
+            + "/latest"
+        )
         self.assertEqual(url, meeting.edit_link_to_pad)
 
     def test_update_from_launchpad_sets_status(self):
-        meeting = Meeting()
+        summit = factory.make_one(Summit, timezone='utc', name='test-summit')
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name='test-meeting',
+            summit=summit,
+            private=False
+        )
         status = "Discussion"
-        elem = LaunchpadExportNode(status=status)
+        name = meeting.name
+        elem = LaunchpadExportNode(status=status, name=name)
         meeting.update_from_launchpad(elem)
         self.assertEqual(status, meeting.status)
 
     def test_update_from_launchpad_sets_priority(self):
-        meeting = Meeting()
+        summit = factory.make_one(Summit, timezone='utc', name='test-summit')
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name='test-meeting',
+            summit=summit,
+            private=False
+        )
         priority = 70
-        elem = LaunchpadExportNode(priority=priority)
+        name = meeting.name
+        elem = LaunchpadExportNode(priority=priority, name=name)
         meeting.update_from_launchpad(elem)
         self.assertEqual(priority, meeting.priority)
 
     def test_update_from_launchpad_sets_wiki_url(self):
-        meeting = Meeting()
+        summit = factory.make_one(Summit, timezone='utc', name='test-summit')
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name='test-meeting',
+            summit=summit,
+            private=False
+        )
         wiki_url = "http://example.com/somespec"
-        elem = LaunchpadExportNode(specurl=wiki_url)
+        name = meeting.name
+        elem = LaunchpadExportNode(specurl=wiki_url, name=name)
         meeting.update_from_launchpad(elem)
         self.assertEqual(wiki_url, meeting.wiki_url)
 
     def get_person_node(self, username, required=False):
         elem = LaunchpadExportNode()
         required_map = {True: "True", False: "False"}
-        elem.add_child("person",
-                LaunchpadExportNode(name=username,
-                    required=required_map[required]))
+        elem.add_child(
+            "person",
+            LaunchpadExportNode(
+                name=username,
+                required=required_map[required]
+            )
+        )
         return elem
 
+    def make_one_future_slot(self, summit=None):
+        if summit is None:
+            summit = factory.make_one(Summit)
+        now = datetime.datetime.utcnow()
+        one_hour = datetime.timedelta(hours=1)
+        return factory.make_one(
+            Slot,
+            summit=summit,
+            start=now+one_hour,
+            end=now+one_hour+one_hour,
+            type='open'
+        )
+
     def make_summit_and_attendee(self):
         username = "username"
         user = factory.make_one(User, username=username)
         summit = factory.make_one(Summit)
-        attendee = summit.attendee_set.create(user=user)
+        slot = self.make_one_future_slot(summit=summit)
+        attendee = summit.attendee_set.create(
+            user=user,
+            start_utc=slot.start_utc,
+            end_utc=slot.end_utc
+        )
         return summit, attendee
 
     def test_update_from_launchpad_adds_participant(self):
         summit, attendee = self.make_summit_and_attendee()
-        meeting = summit.meeting_set.create()
-        elem = self.get_person_node(attendee.user.username, required=False)
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name='test-meeting',
+            summit=summit,
+            private=False
+        )
+        name = meeting.name
+        elem = self.get_person_node(
+            attendee.user.username,
+            required=False,
+        )
         meeting.update_from_launchpad(elem)
         participant = meeting.participant_set.get()
         self.assertEqual(attendee, participant.attendee)
@@ -401,8 +639,18 @@
 
     def test_update_from_launchpad_sets_participant_essential(self):
         summit, attendee = self.make_summit_and_attendee()
-        meeting = summit.meeting_set.create()
-        elem = self.get_person_node(attendee.user.username, required=True)
+        meeting = factory.make_one(
+            Meeting,
+            pad_url=None,
+            name='test-meeting',
+            summit=summit,
+            private=False
+        )
+        name = meeting.name
+        elem = self.get_person_node(
+            attendee.user.username,
+            required=True,
+        )
         meeting.update_from_launchpad(elem)
         participant = meeting.participant_set.get()
         self.assertEqual('INTERESTED', participant.participation)
@@ -421,9 +669,14 @@
         elem = self.get_person_node(attendee.user.username)
         otheruser = factory.make_one(User, username="otheruser")
         otherattendee = summit.attendee_set.create(user=otheruser)
-        meeting.participant_set.create(attendee=otherattendee, from_launchpad=True)
+        meeting.participant_set.create(
+            attendee=otherattendee,
+            from_launchpad=True
+        )
         meeting.update_from_launchpad(elem)
-        usernames = [p.attendee.user.username for p in meeting.participant_set.all()]
+        usernames = [
+            p.attendee.user.username for p in meeting.participant_set.all()
+        ]
         self.assertEqual(["username"], usernames)
 
 
@@ -440,20 +693,38 @@
             start_utc=now,
             end_utc=now+one_hour,
             type='open',
-            summit=summit)
+            summit=summit
+        )
         slot.save()
-        
+
         room = factory.make_one(Room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=summit, name='', private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            name='',
+            private=False
+        )
         meeting.name = ''
         models.Model.save(meeting)
-        agenda = factory.make_one(Agenda, slot=slot, meeting=meeting, room=room)
-        
-        self.assertEquals(meeting.meeting_page_url, '/uds-test/meeting/%s/-/' % meeting.id)
-        
+        agenda = factory.make_one(
+            Agenda,
+            slot=slot,
+            meeting=meeting,
+            room=room
+        )
+
+        self.assertEquals(
+            meeting.meeting_page_url,
+            '/uds-test/meeting/%s/-/' % meeting.id
+        )
+
         response = self.client.get('/uds-test.ical')
         self.assertEquals(response.status_code, 200)
-        self.assertContains(response, 'URL:%s/uds-test/meeting/%s/-/\n' % (site_root, meeting.id), 1)
+        self.assertContains(
+            response,
+            'URL:%s/uds-test/meeting/%s/-/\n' % (site_root, meeting.id),
+            1
+        )
 
     def test_ical_meeting_name_with_period(self):
         """ Tests that ical doesn't break for nameless meetings"""
@@ -466,19 +737,37 @@
             start_utc=now,
             end_utc=now+one_hour,
             type='open',
-            summit=summit)
+            summit=summit
+        )
         slot.save()
-        
+
         room = factory.make_one(Room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=summit, name='test.name', private=False)
-        agenda = factory.make_one(Agenda, slot=slot, meeting=meeting, room=room)
-        
-        self.assertEquals(meeting.meeting_page_url, '/uds-test/meeting/%s/test.name/' % meeting.id)
-        
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            name='test.name',
+            private=False
+        )
+        agenda = factory.make_one(
+            Agenda,
+            slot=slot,
+            meeting=meeting,
+            room=room
+        )
+
+        self.assertEquals(
+            meeting.meeting_page_url,
+            '/uds-test/meeting/%s/test.name/' % meeting.id
+        )
+
         response = self.client.get('/uds-test.ical')
         self.assertEquals(response.status_code, 200)
-        self.assertContains(response, 'URL:%s/uds-test/meeting/%s/test.name/' % (site_root, meeting.id), 1)
-        
+        self.assertContains(
+            response,
+            'URL:%s/uds-test/meeting/%s/test.name/' % (site_root, meeting.id),
+            1
+        )
+
     def test_ical_meeting_multiline_description(self):
         """ Tests that ical put spaces before multi-line descriptions"""
         now = datetime.datetime.utcnow()
@@ -490,19 +779,34 @@
             start_utc=now,
             end_utc=now+one_hour,
             type='open',
-            summit=summit)
+            summit=summit
+        )
         slot.save()
-        
+
         room = factory.make_one(Room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=summit, name='test.name', description="Test\r\nDescription", private=False)
-        agenda = factory.make_one(Agenda, slot=slot, meeting=meeting, room=room)
-        
-        self.assertEquals(meeting.meeting_page_url, '/uds-test/meeting/%s/test.name/' % meeting.id)
-        
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            name='test.name',
+            description="Test\r\nDescription",
+            private=False
+        )
+        agenda = factory.make_one(
+            Agenda,
+            slot=slot,
+            meeting=meeting,
+            room=room
+        )
+
+        self.assertEquals(
+            meeting.meeting_page_url,
+            '/uds-test/meeting/%s/test.name/' % meeting.id
+        )
+
         response = self.client.get('/uds-test.ical')
         self.assertEquals(response.status_code, 200)
         self.assertContains(response, 'DESCRIPTION:Test\NDescription', 1)
-        
+
     def test_private_ical(self):
         """ Tests that private icals contain private meetings """
         now = datetime.datetime.utcnow()
@@ -514,21 +818,57 @@
             start_utc=now,
             end_utc=now+one_hour,
             type='open',
-            summit=summit)
-        
+            summit=summit
+        )
+
         room = factory.make_one(Room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=summit, name='test.name', private=True)
-        agenda = factory.make_one(Agenda, slot=slot, meeting=meeting, room=room)
-        
-        self.assertEquals(meeting.meeting_page_url, '/uds-test/meeting/%s/test.name/' % meeting.id)
-
-        user = factory.make_one(User, username='testuser', first_name='Test', last_name='User')
-        attendee = factory.make_one(Attendee, summit=summit, user=user, start_utc=now, end_utc=now+week)
-        participant = factory.make_one(Participant, attendee=attendee, meeting=meeting)
-
-        response = self.client.get('/uds-test/participant/my_schedule_%s.ical' % attendee.secret_key)
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            name='test.name',
+            private=True
+        )
+        agenda = factory.make_one(
+            Agenda,
+            slot=slot,
+            meeting=meeting,
+            room=room
+        )
+
+        self.assertEquals(
+            meeting.meeting_page_url,
+            '/uds-test/meeting/%s/test.name/' % meeting.id
+        )
+
+        user = factory.make_one(
+            User,
+            username='testuser',
+            first_name='Test',
+            last_name='User'
+        )
+        attendee = factory.make_one(
+            Attendee,
+            summit=summit,
+            user=user,
+            start_utc=now,
+            end_utc=now+week
+        )
+        participant = factory.make_one(
+            Participant,
+            attendee=attendee,
+            meeting=meeting
+        )
+
+        response = self.client.get(
+            '/uds-test/participant/my_schedule_%s.ical' % attendee.secret_key
+        )
         self.assertEquals(response.status_code, 200)
-        self.assertContains(response, 'URL:%s/uds-test/meeting/%s/test.name/' % (site_root, meeting.id), 1)
+        self.assertContains(
+            response,
+            'URL:%s/uds-test/meeting/%s/test.name/' % (site_root, meeting.id),
+            1
+        )
+
 
 class MeetingPageTestCase(djangotest.TestCase):
 
@@ -543,21 +883,38 @@
             start_utc=now,
             end_utc=now+one_hour,
             type='open',
-            summit=summit)
+            summit=summit
+        )
         slot.save()
-        
+
         room = factory.make_one(Room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=summit, name='test-meeting', private=False)
-        agenda = factory.make_one(Agenda, slot=slot, meeting=meeting, room=room)
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            name='test-meeting',
+            private=False
+        )
+        agenda = factory.make_one(
+            Agenda,
+            slot=slot,
+            meeting=meeting,
+            room=room
+        )
 
         # check meeting page url generation
-        self.assertEquals(meeting.meeting_page_url, '/uds-test/meeting/%s/test-meeting/' % meeting.id)
-        
+        self.assertEquals(
+            meeting.meeting_page_url,
+            '/uds-test/meeting/%s/test-meeting/' % meeting.id
+        )
+
         # check meeting page url reverse lookup
-        rev_args = ['uds-test', 1, 'test-meeting']
+        rev_args = ['uds-test', meeting.id, 'test-meeting']
         reverse_url = reverse('summit.schedule.views.meeting', args=rev_args)
-        self.assertEquals(reverse_url, '/uds-test/meeting/%s/test-meeting/' % meeting.id)
-        
+        self.assertEquals(
+            reverse_url,
+            '/uds-test/meeting/%s/test-meeting/' % meeting.id
+        )
+
         # check meeting details page
         response = self.client.get(reverse_url)
         self.assertEquals(response.status_code, 200)
@@ -565,7 +922,14 @@
         # check meeting in ical
         response = self.client.get('/uds-test.ical')
         self.assertEquals(response.status_code, 200)
-        self.assertContains(response, 'URL:%s/uds-test/meeting/%s/test-meeting/' % (site_root, meeting.id), 1)
+        self.assertContains(
+            response,
+            'URL:%s/uds-test/meeting/%s/test-meeting/' % (
+                site_root,
+                meeting.id
+            ),
+            1
+        )
 
 
 class ParticipationRegistrationTestCase(djangotest.TestCase):
@@ -580,61 +944,157 @@
             start_utc=now+one_hour,
             end_utc=now+(2*one_hour),
             type='open',
-            summit=self.summit)
-        
+            summit=self.summit
+        )
+
         self.room = factory.make_one(Room, summit=self.summit, type='open')
-        self.meeting = factory.make_one(Meeting, summit=self.summit, name='meeting1', private=False, requires_dial_in=False, spec_url=None)
+        self.meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting1',
+            private=False,
+            requires_dial_in=False,
+            spec_url=''
+        )
 
-        self.user = factory.make_one(User, username='testuser', first_name='Test', last_name='User', is_active=True)
+        self.user = factory.make_one(
+            User,
+            username='testuser',
+            first_name='Test',
+            last_name='User',
+            is_active=True
+        )
         self.user.set_password('password')
         self.user.save()
 
-        self.attendee = factory.make_one(Attendee, summit=self.summit, user=self.user, start_utc=now, end_utc=now+week)
-        
+        self.attendee = factory.make_one(
+            Attendee,
+            summit=self.summit,
+            user=self.user,
+            start_utc=now,
+            end_utc=now+week
+        )
+
+    def tearDown(self):
+        pass
+
     def login(self):
         logged_in = self.client.login(username='testuser', password='password')
         self.assertTrue(logged_in)
-        
+
     def test_attend_link(self):
-        self.assertEquals(0, Participant.objects.filter(attendee=self.attendee).count())
+        self.assertEquals(
+            0,
+            Participant.objects.filter(
+                attendee=self.attendee
+            ).count()
+        )
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.meeting', args=('uds-test', self.meeting.id, 'meeting1')))
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.meeting',
+                args=('uds-test', self.meeting.id, 'meeting1')
+            )
+        )
         self.assertContains(response, 'Attend this meeting', 1)
         self.assertContains(response, 'Subscribe to this meeting', 0)
         self.assertContains(response, 'Skip this meeting', 0)
 
     def test_subscribe_link(self):
-        self.assertEquals(0, Participant.objects.filter(attendee=self.attendee).count())
+        self.assertEquals(
+            0,
+            Participant.objects.filter(
+                attendee=self.attendee
+            ).count()
+        )
         self.login()
         self.meeting.spec_url = 'http://examplespec.com/test'
         self.meeting.save()
-        response = self.client.get(reverse('summit.schedule.views.meeting', args=('uds-test', self.meeting.id, 'meeting1')))
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.meeting',
+                args=('uds-test', self.meeting.id, 'meeting1')
+            )
+        )
         self.assertContains(response, 'Subscribe to blueprint', 1)
-        self.assertContains(response, 'http://examplespec.com/test/+subscribe', 1)
+        self.assertContains(
+            response,
+            'http://examplespec.com/test/+subscribe',
+            1
+        )
         self.assertContains(response, 'Attend this meeting', 1)
         self.assertContains(response, 'Skip this meeting', 0)
 
     def test_skip_link(self):
-        self.meeting.participant_set.create(attendee=self.attendee, participation = 'ATTENDING', from_launchpad=False)
-        self.assertEquals(1, Participant.objects.filter(attendee=self.attendee).count())
+        self.meeting.participant_set.create(
+            attendee=self.attendee,
+            participation='ATTENDING',
+            from_launchpad=False
+        )
+        self.assertEquals(
+            1,
+            Participant.objects.filter(
+                attendee=self.attendee
+            ).count()
+        )
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.meeting', args=('uds-test', self.meeting.id, 'meeting1')))
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.meeting',
+                args=('uds-test', self.meeting.id, 'meeting1')
+            )
+        )
         self.assertContains(response, 'Skip this meeting', 1)
         self.assertContains(response, 'Subscribe to this meeting', 0)
         self.assertContains(response, 'Attend this meeting', 0)
 
     def test_add_participation(self):
-        self.assertEquals(0, Participant.objects.filter(attendee=self.attendee).count())
+        self.assertEquals(
+            0,
+            Participant.objects.filter(
+                attendee=self.attendee
+            ).count()
+        )
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.register', args=('uds-test', self.meeting.id, 'meeting1')))
-        self.assertEquals(1, Participant.objects.filter(attendee=self.attendee).count())
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.register',
+                args=('uds-test', self.meeting.id, 'meeting1')
+            )
+        )
+        self.assertEquals(
+            1,
+            Participant.objects.filter(
+                attendee=self.attendee
+            ).count()
+        )
 
     def test_delete_participation(self):
-        self.meeting.participant_set.create(attendee=self.attendee, participation = 'ATTENDING', from_launchpad=False)
-        self.assertEquals(1, Participant.objects.filter(attendee=self.attendee).count())
+        self.meeting.participant_set.create(
+            attendee=self.attendee,
+            participation='ATTENDING',
+            from_launchpad=False
+        )
+        self.assertEquals(
+            1,
+            Participant.objects.filter(
+                attendee=self.attendee
+            ).count()
+        )
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.unregister', args=('uds-test', self.meeting.id, 'meeting1')))
-        self.assertEquals(0, Participant.objects.filter(attendee=self.attendee).count())
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.unregister',
+                args=('uds-test', self.meeting.id, 'meeting1')
+            )
+        )
+        self.assertEquals(
+            0,
+            Participant.objects.filter(
+                attendee=self.attendee
+            ).count()
+        )
+
 
 class ReverseUrlLookupTestCase(djangotest.TestCase):
 
@@ -648,19 +1108,30 @@
             start_utc=now,
             end_utc=now+one_hour,
             type='open',
-            summit=self.summit)
+            summit=self.summit
+        )
         self.slot.save()
-        
+
+    def tearDown(self):
+        pass
+
     def test_meeting_name_with_period(self):
         ''' Test the following Meeting urlconf
         (r'^(?P<summit_name>[\w-]+)/meeting/(?P<meeting_id>\d+)/(?P<meeting_slug>[\.\w-]+)/$', 'meeting'),
         '''
-        meeting = factory.make_one(Meeting, summit=self.summit, name='test.meeting', private=False)
-        
+        meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='test.meeting',
+            private=False
+        )
+
         rev_args = ['uds-test', meeting.id, 'test.meeting']
         reverse_url = reverse('summit.schedule.views.meeting', args=rev_args)
-        self.assertEquals(reverse_url, '/uds-test/meeting/%s/test.meeting/' % meeting.id)
-
+        self.assertEquals(
+            reverse_url,
+            '/uds-test/meeting/%s/test.meeting/' % meeting.id
+        )
 
     def test_room_name_with_period(self):
         ''' Test the following Room urlconfs
@@ -687,9 +1158,12 @@
         reverse_url = reverse('summit.schedule.views.by_track', args=rev_args)
         self.assertEquals(reverse_url, '/uds-test/track/test.track/')
 
-        reverse_url = reverse('summit.schedule.views.track_ical', args=rev_args)
+        reverse_url = reverse(
+            'summit.schedule.views.track_ical',
+            args=rev_args
+        )
         self.assertEquals(reverse_url, '/uds-test/track/test.track.ical')
-        
+
     def test_participant_name_with_period(self):
         ''' Test the following User urlconf
         (r'^(?P<summit_name>[\w-]+)/participant/(?P<username>[\w-]+)\.ical$', 'user_ical'),
@@ -699,22 +1173,38 @@
         rev_args = ['uds-test', 'test.user']
         reverse_url = reverse('summit.schedule.views.user_ical', args=rev_args)
         self.assertEquals(reverse_url, '/uds-test/participant/test.user.ical')
-        
+
     def test_meeting_name_with_percent(self):
         ''' Test the following Meeting urlconf
         (r'^(?P<summit_name>[\w-]+)/meeting/(?P<meeting_id>\d+)/(?P<meeting_slug>[\.\w-]+)/$', 'meeting'),
         '''
-        meeting = factory.make_one(Meeting, summit=self.summit, name='test.meeting', private=False)
-        
+        meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='test.meeting',
+            private=False
+        )
+
         rev_args = ['uds-test', meeting.id, 'test%meeting']
         reverse_url = reverse('summit.schedule.views.meeting', args=rev_args)
-        self.assertEquals(reverse_url, '/uds-test/meeting/%s/test%%meeting/' % meeting.id)
+        self.assertEquals(
+            reverse_url,
+            '/uds-test/meeting/%s/test%%meeting/' % meeting.id
+        )
 
     def test_meeting_name_with_plus_sign(self):
-        meeting = factory.make_one(Meeting, summit=self.summit, name='test.meeting', private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='test.meeting',
+            private=False
+        )
         rev_args = ['uds-test', meeting.id, 'test+meeting']
         reverse_url = reverse('summit.schedule.views.meeting', args=rev_args)
-        self.assertEquals(reverse_url, '/uds-test/meeting/%s/test+meeting/' % meeting.id)
+        self.assertEquals(
+            reverse_url,
+            '/uds-test/meeting/%s/test+meeting/' % meeting.id
+        )
 
     def test_room_name_with_percent(self):
         ''' Test the following Room urlconfs
@@ -751,7 +1241,10 @@
         reverse_url = reverse('summit.schedule.views.by_track', args=rev_args)
         self.assertEquals(reverse_url, '/uds-test/track/test%track/')
 
-        reverse_url = reverse('summit.schedule.views.track_ical', args=rev_args)
+        reverse_url = reverse(
+            'summit.schedule.views.track_ical',
+            args=rev_args
+        )
         self.assertEquals(reverse_url, '/uds-test/track/test%track.ical')
 
     def test_track_name_with_plus_sign(self):
@@ -761,7 +1254,10 @@
         reverse_url = reverse('summit.schedule.views.by_track', args=rev_args)
         self.assertEquals(reverse_url, '/uds-test/track/test+track/')
 
-        reverse_url = reverse('summit.schedule.views.track_ical', args=rev_args)
+        reverse_url = reverse(
+            'summit.schedule.views.track_ical',
+            args=rev_args
+        )
         self.assertEquals(reverse_url, '/uds-test/track/test+track.ical')
 
     def test_participant_name_with_percent(self):
@@ -781,6 +1277,7 @@
         reverse_url = reverse('summit.schedule.views.user_ical', args=rev_args)
         self.assertEquals(reverse_url, '/uds-test/participant/test+user.ical')
 
+
 class EtherpadEditUrl(djangotest.TestCase):
 
     def setUp(self):
@@ -799,12 +1296,29 @@
         slot.save()
 
         room = factory.make_one(Room, summit=self.summit)
-        meeting = factory.make_one(Meeting, summit=self.summit, name='test-meeting', private=False)
-        agenda = factory.make_one(Agenda, slot=slot, meeting=meeting, room=room)
+        meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='test-meeting',
+            private=False
+        )
+        agenda = factory.make_one(
+            Agenda,
+            slot=slot,
+            meeting=meeting,
+            room=room
+        )
 
-        response = self.client.get('/uds-test/meeting/%s/test-meeting/' % meeting.id)
+        response = self.client.get(
+            '/uds-test/meeting/%s/test-meeting/' % meeting.id
+        )
         self.assertEquals(response.status_code, 200)
-        self.assertContains(response, 'http://pad.ubuntu.com/ep/pad/view/uds-test-test-meeting/latest', 1)
+        self.assertContains(
+            response,
+            'http://pad.ubuntu.com/ep/pad/view/uds-test-test-meeting/latest',
+            1
+        )
+
 
 class SchedulingConflictsTestCase(djangotest.TestCase):
 
@@ -819,24 +1333,52 @@
             end_utc=now+one_hour,
             type='open',
             summit=self.summit)
-        
+
         self.room1 = factory.make_one(Room, summit=self.summit)
-        self.meeting1 = factory.make_one(Meeting, summit=self.summit, name='meeting1', requires_dial_in=False)
-        self.agenda1 = factory.make_one(Agenda, slot=self.slot, meeting=self.meeting1, room=self.room1)
+        self.meeting1 = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting1',
+            requires_dial_in=False
+        )
+        self.agenda1 = factory.make_one(
+            Agenda,
+            slot=self.slot,
+            meeting=self.meeting1,
+            room=self.room1
+        )
 
         self.room2 = factory.make_one(Room, summit=self.summit)
-        self.meeting2 = factory.make_one(Meeting, summit=self.summit, name='meeting2', requires_dial_in=False)
-        
-        self.user = factory.make_one(User, username='testuser', first_name='Test', last_name='User')
-        self.attendee = factory.make_one(Attendee, summit=self.summit, user=self.user, start_utc=now, end_utc=now+week)
-        
+        self.meeting2 = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting2',
+            requires_dial_in=False
+        )
+
+        self.user = factory.make_one(
+            User,
+            username='testuser',
+            first_name='Test',
+            last_name='User'
+        )
+        self.attendee = factory.make_one(
+            Attendee,
+            summit=self.summit,
+            user=self.user,
+            start_utc=now,
+            end_utc=now+week
+        )
+
     def tearDown(self):
         pass
-        
+
     def assertRaises(self, exception_type, function, args):
         try:
             function(*args)
-            raise AssertionError('Callable failed to raise exception %s' % exception_type)
+            raise AssertionError(
+                'Callable failed to raise exception %s' % exception_type
+            )
         except exception_type, e:
             return True
 
@@ -844,21 +1386,25 @@
         '''Checks the Meeting model's check_schedule'''
         missing = self.meeting1.check_schedule(self.slot, self.room1)
         self.assertEquals(len(missing), 0)
-        
+
         missing = self.meeting2.check_schedule(self.slot, self.room2)
         self.assertEquals(len(missing), 0)
-        
+
     def test_meeting_check_room_conflict(self):
-        '''Checks that two meetings will not be scheduled in the same room 
+        '''Checks that two meetings will not be scheduled in the same room
             at the same time
         '''
         missing = self.meeting1.check_schedule(self.slot, self.room1)
         self.assertEquals(len(missing), 0)
-        
-        self.assertRaises(Meeting.SchedulingError,
-                          Meeting.check_schedule, 
-                          (self.meeting2, self.slot, self.room1))
-        
+
+        self.assertRaises(
+            Meeting.SchedulingError,
+            Meeting.check_schedule,
+            (self.meeting2,
+             self.slot,
+             self.room1)
+        )
+
     def test_meeting_check_schedule_participant_conflict(self):
         '''Checks that a two meetings requiring the same attendee will mark that
             user as missing.
@@ -866,19 +1412,20 @@
         participant1 = Participant.objects.create(
             meeting=self.meeting1,
             attendee=self.attendee,
-            participation = 'REQUIRED'
+            participation='REQUIRED'
         )
         missing = self.meeting1.check_schedule(self.slot, self.room1)
         self.assertEquals(len(missing), 0)
-        
+
         participant1 = Participant.objects.create(
             meeting=self.meeting2,
             attendee=self.attendee,
-            participation = 'REQUIRED'
+            participation='REQUIRED'
         )
         missing = self.meeting2.check_schedule(self.slot, self.room2)
         self.assertEquals(len(missing), 1)
 
+
 class AutoSchedulerTestCase(djangotest.TestCase):
     def setUp(self):
         now = datetime.datetime.utcnow()
@@ -890,40 +1437,75 @@
             start_utc=now+week,
             end_utc=now+week+one_hour,
             type='open',
-            summit=self.summit)
-        
+            summit=self.summit
+        )
+
         self.room1 = factory.make_one(Room, summit=self.summit, type='open')
-        self.meeting1 = factory.make_one(Meeting, summit=self.summit, name='meeting1', requires_dial_in=False, approved='APPROVED', private=False)
-        self.agenda1 = factory.make_one(Agenda, slot=self.slot, meeting=self.meeting1, room=self.room1)
+        self.meeting1 = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting1',
+            requires_dial_in=False,
+            approved='APPROVED',
+            private=False
+        )
+        self.agenda1 = factory.make_one(
+            Agenda,
+            slot=self.slot,
+            meeting=self.meeting1,
+            room=self.room1
+        )
 
         self.room2 = factory.make_one(Room, summit=self.summit, type='open')
-        self.meeting2 = factory.make_one(Meeting, summit=self.summit, name='meeting2', requires_dial_in=False, approved='APPROVED', private=False)
-        
-        self.user = factory.make_one(User, username='testuser', first_name='Test', last_name='User')
-        self.attendee = factory.make_one(Attendee, summit=self.summit, user=self.user, start_utc=now, end_utc=now+week)
-        
+        self.meeting2 = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting2',
+            requires_dial_in=False,
+            approved='APPROVED',
+            private=False
+        )
+
+        self.user = factory.make_one(
+            User,
+            username='testuser',
+            first_name='Test',
+            last_name='User'
+        )
+        self.attendee = factory.make_one(
+            Attendee,
+            summit=self.summit,
+            user=self.user,
+            start_utc=now,
+            end_utc=now+week
+        )
+
     def tearDown(self):
         pass
 
     def run_autoschedule(self):
         from django.core.management import execute_from_command_line
-        execute_from_command_line(argv=['manage.py', 'autoschedule', 'uds-test', '-v', '2'])
+        execute_from_command_line(
+            argv=['manage.py', 'autoschedule', 'uds-test', '-v', '2']
+        )
 
     def run_reschedule(self):
         from django.core.management import execute_from_command_line
-        execute_from_command_line(argv=['manage.py', 'reschedule', 'uds-test', '-v', '2'])
+        execute_from_command_line(
+            argv=['manage.py', 'reschedule', 'uds-test', '-v', '2']
+        )
 
     def test_required_conflict(self):
         participant1 = Participant.objects.create(
             meeting=self.meeting1,
             attendee=self.attendee,
-            participation = 'REQUIRED'
+            participation='REQUIRED'
         )
 
         participant2 = Participant.objects.create(
             meeting=self.meeting2,
             attendee=self.attendee,
-            participation = 'REQUIRED'
+            participation='REQUIRED'
         )
 
         self.run_autoschedule()
@@ -935,13 +1517,13 @@
         participant1 = Participant.objects.create(
             meeting=self.meeting1,
             attendee=self.attendee,
-            participation = 'REQUIRED'
+            participation='REQUIRED'
         )
 
         participant2 = Participant.objects.create(
             meeting=self.meeting2,
             attendee=self.attendee,
-            participation = 'INTERESTED'
+            participation='INTERESTED'
         )
 
         self.run_autoschedule()
@@ -953,13 +1535,13 @@
         participant1 = Participant.objects.create(
             meeting=self.meeting1,
             attendee=self.attendee,
-            participation = 'REQUIRED'
+            participation='REQUIRED'
         )
 
         participant2 = Participant.objects.create(
             meeting=self.meeting2,
             attendee=self.attendee,
-            participation = 'INTERESTED'
+            participation='INTERESTED'
         )
 
         self.run_autoschedule()
@@ -969,32 +1551,50 @@
 
         participant2.participation = 'REQUIRED'
         participant2.save()
-        
+
         self.run_reschedule()
 
-        self.assertEquals(1, self.meeting1.agenda_set.all().count())
-        self.assertEquals(0, self.meeting2.agenda_set.all().count())        
+        self.assertEquals(0, self.meeting1.agenda_set.all().count())
+        self.assertEquals(0, self.meeting2.agenda_set.all().count())
 
     def test_get_participants_by_level(self):
         participant1 = Participant.objects.create(
             meeting=self.meeting1,
             attendee=self.attendee,
-            participation = 'REQUIRED'
+            participation='REQUIRED'
         )
 
         participant2 = Participant.objects.create(
             meeting=self.meeting2,
             attendee=self.attendee,
-            participation = 'INTERESTED'
-        )
-
-        self.assertEquals(1, len(self.meeting1.get_participants_by_level('REQUIRED')))
-        self.assertEquals(0, len(self.meeting1.get_participants_by_level('INTERESTED')))
-        self.assertEquals(0, len(self.meeting1.get_participants_by_level('ATTENDING')))
-
-        self.assertEquals(0, len(self.meeting2.get_participants_by_level('REQUIRED')))
-        self.assertEquals(1, len(self.meeting2.get_participants_by_level('INTERESTED')))
-        self.assertEquals(0, len(self.meeting2.get_participants_by_level('ATTENDING')))
+            participation='INTERESTED'
+        )
+
+        self.assertEquals(
+            1,
+            len(self.meeting1.get_participants_by_level('REQUIRED'))
+        )
+        self.assertEquals(
+            0, len(self.meeting1.get_participants_by_level('INTERESTED'))
+        )
+        self.assertEquals(
+            0,
+            len(self.meeting1.get_participants_by_level('ATTENDING'))
+        )
+
+        self.assertEquals(
+            0,
+            len(self.meeting2.get_participants_by_level('REQUIRED'))
+        )
+        self.assertEquals(
+            1,
+            len(self.meeting2.get_participants_by_level('INTERESTED'))
+        )
+        self.assertEquals(
+            0,
+            len(self.meeting2.get_participants_by_level('ATTENDING'))
+        )
+
 
 class PrivateSchedulingTestCase(djangotest.TestCase):
 
@@ -1008,49 +1608,117 @@
             start_utc=now+one_hour,
             end_utc=now+(2*one_hour),
             type='open',
-            summit=self.summit)
-        
-        self.open_room = factory.make_one(Room, summit=self.summit, type='open')
-        self.public_meeting = factory.make_one(Meeting, summit=self.summit, name='meeting1', private=False, requires_dial_in=False, approved='APPROVED')
-
-        self.private_room = factory.make_one(Room, summit=self.summit, type='private')
-        self.private_meeting = factory.make_one(Meeting, summit=self.summit, name='meeting2', private=True, requires_dial_in=False, approved='APPROVED')
-        
-        self.user = factory.make_one(User, username='testuser', first_name='Test', last_name='User')
-        self.attendee = factory.make_one(Attendee, summit=self.summit, user=self.user, start_utc=now, end_utc=now+week)
-        
+            summit=self.summit
+        )
+
+        self.open_room = factory.make_one(
+            Room,
+            summit=self.summit,
+            type='open'
+        )
+        self.public_meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting1',
+            private=False,
+            requires_dial_in=False,
+            approved='APPROVED'
+        )
+
+        self.private_room = factory.make_one(
+            Room,
+            summit=self.summit,
+            type='private'
+        )
+        self.private_meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting2',
+            private=True,
+            requires_dial_in=False,
+            approved='APPROVED'
+        )
+
+        self.user = factory.make_one(
+            User,
+            username='testuser',
+            first_name='Test',
+            last_name='User'
+        )
+        self.attendee = factory.make_one(
+            Attendee,
+            summit=self.summit,
+            user=self.user,
+            start_utc=now,
+            end_utc=now+week
+        )
+
     def tearDown(self):
         pass
-        
+
     def assertRaises(self, exception_type, function, args):
         try:
             function(*args)
-            raise AssertionError('Callable failed to raise exception %s' % exception_type)
+            raise AssertionError(
+                'Callable failed to raise exception %s' % exception_type
+            )
         except exception_type, e:
             return True
 
     def run_autoschedule(self):
         from django.core.management import execute_from_command_line
-        execute_from_command_line(argv=['manage.py', 'autoschedule', 'uds-test', '-v', '2'])
+        execute_from_command_line(
+            argv=['manage.py', 'autoschedule', 'uds-test', '-v', '2']
+        )
 
     def test_private_meeting_schedule(self):
         ''' General run of the autoschedule, no gurantee of what ends up where'''
         self.run_autoschedule()
 
         # Private meetings should not ever be autoscheduled
-        self.assertEquals(0, Agenda.objects.filter(slot__summit=self.summit, meeting__private=True, room__type='open').count())
-        self.assertEquals(0, Agenda.objects.filter(slot__summit=self.summit, meeting__private=False, room__type='private').count())
+        self.assertEquals(
+            0,
+            Agenda.objects.filter(
+                slot__summit=self.summit,
+                meeting__private=True,
+                room__type='open'
+            ).count()
+        )
+        self.assertEquals(
+            0,
+            Agenda.objects.filter(
+                slot__summit=self.summit,
+                meeting__private=False,
+                room__type='private'
+            ).count()
+        )
         # Private rooms should not ever be autoscheduled
-        self.assertEquals(0, Agenda.objects.filter(slot__summit=self.summit, meeting__private=True, room__type='private').count())
+        self.assertEquals(
+            0,
+            Agenda.objects.filter(
+                slot__summit=self.summit,
+                meeting__private=True,
+                room__type='private'
+            ).count()
+        )
 
         # Public meetings in open rooms should be autoscheduled
-        self.assertEquals(1, Agenda.objects.filter(slot__summit=self.summit, meeting__private=False, room__type='open').count())
+        self.assertEquals(
+            1,
+            Agenda.objects.filter(
+                slot__summit=self.summit,
+                meeting__private=False,
+                room__type='open'
+            ).count()
+        )
 
     def test_no_available_public_room(self):
-        '''Make sure public meetings will not be autoscheduled into private rooms'''
+        '''
+        Make sure public meetings will not be autoscheduled into private rooms
+        '''
         self.open_room.type = 'private'
         self.open_room.save()
-        
+
         self.run_autoschedule()
 
         # Without an open room, public meetings should not be autoscheduled
@@ -1058,17 +1726,19 @@
 
         # Private meetings should not ever be autoscheduled
         self.assertEquals(0, self.private_meeting.agenda_set.count())
-        
+
         # Private rooms should not ever be autoscheduled
         self.assertEquals(0, Agenda.objects.filter(room__type='private').count())
-    
+
     def test_no_available_private_room(self):
-        '''Make sure private meetings will not be autoscheduled into open rooms'''
+        '''
+        Make sure private meetings will not be autoscheduled into open rooms
+        '''
         self.private_room.type = 'open'
         self.private_room.save()
-        
+
         self.run_autoschedule()
-        
+
         # Private meetings should not ever be autoscheduled
         self.assertEquals(0, self.private_meeting.agenda_set.count())
 
@@ -1077,17 +1747,32 @@
         self.assertEquals(1, Agenda.objects.filter(room__type='open').count())
 
     def test_required_participant_in_private_meeting(self):
-        '''Make sure meetings aren't scheduled when someone is in a private meeting.'''
+        '''
+        Make sure meetings aren't scheduled when
+        someone is in a private meeting.
+        '''
         # Make the same person required for both meetings
-        self.public_meeting.participant_set.create(attendee=self.attendee, participation = 'REQUIRED')
-        self.private_meeting.participant_set.create(attendee=self.attendee, participation = 'REQUIRED')
+        self.public_meeting.participant_set.create(
+            attendee=self.attendee,
+            participation='REQUIRED'
+        )
+        self.private_meeting.participant_set.create(
+            attendee=self.attendee,
+            participation='REQUIRED'
+        )
         # Schedule the private meeting in the one available slot
-        self.private_room.agenda_set.create(slot=self.slot, meeting=self.private_meeting)
+        self.private_room.agenda_set.create(
+            slot=self.slot,
+            meeting=self.private_meeting
+        )
 
         self.run_autoschedule()
 
         # Check that the private meeting is still scheduled
-        self.assertEquals(1, self.private_meeting.agenda_set.count())
+        self.assertEquals(
+            1,
+            self.private_meeting.agenda_set.count()
+        )
         # Check that the public meeting is not scheduled
         self.assertEquals(0, self.public_meeting.agenda_set.count())
 
@@ -1104,15 +1789,46 @@
             start_utc=now+one_hour,
             end_utc=now+(2*one_hour),
             type='open',
-            summit=self.summit)
-
-        self.track1 = factory.make_one(Track, slug='test_slug', summit=self.summit)
-        self.room1 = factory.make_one(Room, summit=self.summit, name='room1')
-        self.meeting1 = factory.make_one(Meeting, summit=self.summit, name='meeting1', private=False, requires_dial_in=False)
-        self.agenda1 = factory.make_one(Agenda, slot=self.slot, meeting=self.meeting1, room=self.room1)
-
-        self.user = factory.make_one(User, username='testuser', first_name='Test', last_name='User')
-        self.attendee = factory.make_one(Attendee, summit=self.summit, user=self.user, start_utc=now, end_utc=now+week)
+            summit=self.summit
+        )
+
+        self.track1 = factory.make_one(
+            Track,
+            slug='test_slug',
+            summit=self.summit
+        )
+        self.room1 = factory.make_one(
+            Room,
+            summit=self.summit,
+            name='room1'
+        )
+        self.meeting1 = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='meeting1',
+            private=False,
+            requires_dial_in=False
+        )
+        self.agenda1 = factory.make_one(
+            Agenda,
+            slot=self.slot,
+            meeting=self.meeting1,
+            room=self.room1
+        )
+
+        self.user = factory.make_one(
+            User,
+            username='testuser',
+            first_name='Test',
+            last_name='User'
+        )
+        self.attendee = factory.make_one(
+            Attendee,
+            summit=self.summit,
+            user=self.user,
+            start_utc=now,
+            end_utc=now+week
+        )
 
     def tearDown(self):
         # Cached requests cause render.py to return old data, so clear the cache
@@ -1124,7 +1840,10 @@
 
     def request_schedule(self):
         schedule_args = [self.summit.name, self.agenda1.slot.start_utc.date()]
-        schedule_url = reverse('summit.schedule.views.by_date', args=schedule_args)
+        schedule_url = reverse(
+            'summit.schedule.views.by_date',
+            args=schedule_args
+        )
         response = self.client.get(schedule_url)
         return response
 
@@ -1175,13 +1894,21 @@
         self.assertContains(response, 'test%track', 1)
 
     def test_specify_rooms_in_schedule(self):
-        room2 = factory.make_one(Room, summit=self.summit, name='room2', title='Room 2')
+        room2 = factory.make_one(
+            Room,
+            summit=self.summit,
+            name='room2',
+            title='Room 2'
+        )
         self.room1.title = 'Room 1'
         self.room1.save()
         self.agenda1.delete()
-        
+
         schedule_args = [self.summit.name, self.agenda1.slot.start_utc.date()]
-        schedule_url = reverse('summit.schedule.views.by_date', args=schedule_args)
+        schedule_url = reverse(
+            'summit.schedule.views.by_date',
+            args=schedule_args
+        )
 
         response = self.client.get(schedule_url)
         self.assertContains(response, self.room1.title, 2)
@@ -1190,15 +1917,15 @@
         response = self.client.get(schedule_url + '?rooms=room1')
         self.assertContains(response, self.room1.title, 2)
         self.assertContains(response, room2.title, 0)
-        
+
         response = self.client.get(schedule_url + '?rooms=room2')
         self.assertContains(response, self.room1.title, 0)
         self.assertContains(response, room2.title, 2)
-        
+
         response = self.client.get(schedule_url + '?rooms=room1,room2')
         self.assertContains(response, self.room1.title, 2)
         self.assertContains(response, room2.title, 2)
-        
+
         response = self.client.get(schedule_url + '?rooms=unknown1,unknown2')
         self.assertContains(response, self.room1.title, 0)
         self.assertContains(response, room2.title, 0)
@@ -1216,17 +1943,50 @@
             start_utc=now+one_hour,
             end_utc=now+(2*one_hour),
             type='open',
-            summit=self.summit)
+            summit=self.summit
+        )
 
-        self.track = factory.make_one(Track, slug='test.track', summit=self.summit)
-        self.room = factory.make_one(Room, name='test.room', title='Test Room', summit=self.summit)
+        self.track = factory.make_one(
+            Track,
+            slug='test.track',
+            summit=self.summit
+        )
+        self.room = factory.make_one(
+            Room,
+            name='test.room',
+            title='Test Room',
+            summit=self.summit
+        )
         self.room.tracks = [self.track]
-        self.meeting = factory.make_one(Meeting, summit=self.summit, title='Test Meeting', name='meeting', private=False, requires_dial_in=False)
+        self.meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            title='Test Meeting',
+            name='meeting',
+            private=False,
+            requires_dial_in=False
+        )
         self.meeting.tracks = [self.track]
-        self.agenda = factory.make_one(Agenda, slot=self.slot, meeting=self.meeting, room=self.room)
+        self.agenda = factory.make_one(
+            Agenda,
+            slot=self.slot,
+            meeting=self.meeting,
+            room=self.room
+        )
 
-        self.user = factory.make_one(User, username='testuser', first_name='Test', last_name='User')
-        self.attendee = factory.make_one(Attendee, summit=self.summit, user=self.user, start_utc=now, end_utc=now+week)
+        self.user = factory.make_one(
+            User,
+            username='testuser',
+            first_name='Test',
+            last_name='User'
+        )
+        self.attendee = factory.make_one(
+            Attendee,
+            summit=self.summit,
+            user=self.user,
+            start_utc=now,
+            end_utc=now+week
+        )
 
     def tearDown(self):
         # Cached requests cause render.py to return old data, so clear the cache
@@ -1238,37 +1998,63 @@
 
     def request_schedule_by_date(self):
         schedule_args = [self.summit.name, self.agenda.slot.start_utc.date()]
-        schedule_url = reverse('summit.schedule.views.by_date', args=schedule_args)
+        schedule_url = reverse(
+            'summit.schedule.views.by_date',
+            args=schedule_args
+        )
         response = self.client.get(schedule_url)
         return response
 
     def request_schedule_by_track(self):
         schedule_args = [self.summit.name, self.track.slug]
-        schedule_url = reverse('summit.schedule.views.by_track', args=schedule_args)
+        schedule_url = reverse(
+            'summit.schedule.views.by_track',
+            args=schedule_args
+        )
         response = self.client.get(schedule_url)
         return response
 
     def test_cache_cleared_on_meeting_change(self):
         self.assertEqual(None, cache.get('meeting-html-%s' % self.meeting.id))
         response = self.request_schedule_by_date()
-        self.assertTrue('Test Meeting' in cache.get('meeting-html-%s' % self.meeting.id, ''))
-        
+        self.assertTrue(
+            'Test Meeting' in cache.get(
+                'meeting-html-%s' % self.meeting.id,
+                ''
+            )
+        )
+
         self.meeting.save()
-        
+
         self.assertEqual(None, cache.get('meeting-html-%s' % self.meeting.id))
         response = self.request_schedule_by_date()
-        self.assertTrue('Test Meeting' in cache.get('meeting-html-%s' % self.meeting.id, ''))
+        self.assertTrue(
+            'Test Meeting' in cache.get(
+                'meeting-html-%s' % self.meeting.id,
+                ''
+            )
+        )
 
     def test_cache_cleared_on_agenda_change(self):
         self.assertEqual(None, cache.get('meeting-html-%s' % self.meeting.id))
         response = self.request_schedule_by_date()
-        self.assertTrue('Test Meeting' in cache.get('meeting-html-%s' % self.meeting.id, ''))
-        
+        self.assertTrue(
+            'Test Meeting' in cache.get(
+                'meeting-html-%s' % self.meeting.id,
+                ''
+            )
+        )
+
         self.agenda.save()
-        
+
         self.assertEqual(None, cache.get('meeting-html-%s' % self.meeting.id))
         response = self.request_schedule_by_date()
-        self.assertTrue('Test Meeting' in cache.get('meeting-html-%s' % self.meeting.id, ''))
+        self.assertTrue(
+            'Test Meeting' in cache.get(
+                'meeting-html-%s' % self.meeting.id,
+                ''
+            )
+        )
 
 
 class ScheduleTestCase(djangotest.TestCase):
@@ -1286,11 +2072,16 @@
         self.assertEqual(False, schedule.edit)
 
     def get_user_with_schedule_permission(self):
-        user = factory.make_one(User, is_active=True, is_staff=False,
-                is_superuser=False)
+        user = factory.make_one(
+            User,
+            is_active=True,
+            is_staff=False,
+            is_superuser=False
+        )
         user.user_permissions.create(
             codename='change_agenda',
-            content_type=factory.make_one(ContentType, app_label='schedule'))
+            content_type=factory.make_one(ContentType, app_label='schedule')
+        )
         return user
 
     def get_get_request(self, **kwargs):
@@ -1388,49 +2179,91 @@
     def test_room_set_from_summit_if_not_passed(self):
         request = self.get_request()
         summit = factory.make_one(Summit)
-        room1 = factory.make_one(Room, summit=summit, type='open',
-                name="room1")
-        room2 = factory.make_one(Room, summit=summit, type='open',
-                name="room2")
+        room1 = factory.make_one(
+            Room,
+            summit=summit,
+            type='open',
+            name="room1"
+        )
+        room2 = factory.make_one(
+            Room,
+            summit=summit,
+            type='open',
+            name="room2"
+        )
         factory.make_one(Room, summit=summit, type='closed')
         factory.make_one(Room, summit=summit, type='private')
         schedule = Schedule.from_request(request, summit)
         self.assertEqual(None, schedule.room)
-        self.assertEqual(["room1", "room2"],
-                sorted([r.name for r in schedule.rooms]))
+        self.assertEqual(
+            ["room1", "room2"],
+            sorted([r.name for r in schedule.rooms])
+        )
 
     def test_rooms_include_private_if_user_is_staff(self):
-        user = factory.make_one(User, is_active=True, is_staff=True,
-                is_superuser=False)
+        user = factory.make_one(
+            User,
+            is_active=True,
+            is_staff=True,
+            is_superuser=False
+        )
         request = self.get_request()
         request.user = user
         summit = factory.make_one(Summit)
-        room1 = factory.make_one(Room, summit=summit, type='open',
-                name="room1")
-        room2 = factory.make_one(Room, summit=summit, type='open',
-                name="room2")
+        room1 = factory.make_one(
+            Room,
+            summit=summit,
+            type='open',
+            name="room1"
+        )
+        room2 = factory.make_one(
+            Room,
+            summit=summit,
+            type='open',
+            name="room2"
+        )
         factory.make_one(Room, summit=summit, type='closed')
-        factory.make_one(Room, summit=summit, type='private',
-                name="privateroom")
+        factory.make_one(
+            Room,
+            summit=summit,
+            type='private',
+            name="privateroom"
+        )
         schedule = Schedule.from_request(request, summit)
         self.assertEqual(None, schedule.room)
-        self.assertEqual(["privateroom", "room1", "room2"],
-                sorted([r.name for r in schedule.rooms]))
+        self.assertEqual(
+            ["privateroom", "room1", "room2"],
+            sorted([r.name for r in schedule.rooms])
+        )
 
     def test_rooms_include_private_if_show_private(self):
         request = self.get_request()
         summit = factory.make_one(Summit)
-        room1 = factory.make_one(Room, summit=summit, type='open',
-                name="room1")
-        room2 = factory.make_one(Room, summit=summit, type='open',
-                name="room2")
+        room1 = factory.make_one(
+            Room,
+            summit=summit,
+            type='open',
+            name="room1"
+        )
+        room2 = factory.make_one(
+            Room,
+            summit=summit,
+            type='open',
+            name="room2"
+        )
         factory.make_one(Room, summit=summit, type='closed')
-        factory.make_one(Room, summit=summit, type='private',
-                name="privateroom")
+        factory.make_one(
+            Room,
+            summit=summit,
+            type='private',
+            name="privateroom"
+        )
         schedule = Schedule.from_request(request, summit, show_private=True)
         self.assertEqual(None, schedule.room)
-        self.assertEqual(["privateroom", "room1", "room2"],
-                sorted([r.name for r in schedule.rooms]))
+        self.assertEqual(
+            ["privateroom", "room1", "room2"],
+            sorted([r.name for r in schedule.rooms])
+        )
 
     def test_track_is_none_by_default(self):
         schedule = self.get_schedule_from_request()
@@ -1471,13 +2304,25 @@
         schedule = Schedule.from_request(request, summit)
         self.assertEqual(None, schedule.fakenow)
 
-    def get_schedule(self, edit=False, room=None, summit=None, dates=None,
-            rooms=None):
+    def get_schedule(
+        self,
+        edit=False,
+        room=None,
+        summit=None,
+        dates=None,
+        rooms=None
+    ):
         request = self.get_request()
         if summit is None:
             summit = factory.make_one(Summit)
-        schedule = Schedule(request, summit, edit=edit, room=room,
-            dates=dates, rooms=rooms)
+        schedule = Schedule(
+            request,
+            summit,
+            edit=edit,
+            room=room,
+            dates=dates,
+            rooms=rooms
+        )
         return schedule
 
     def test_calculate_unscheduled_does_nothing_when_read_only(self):
@@ -1487,25 +2332,40 @@
 
     def test_calculate_unscheduled_includes_unscheduled(self):
         schedule = self.get_schedule(edit=True)
-        meeting = factory.make_one(Meeting, summit=schedule.summit, private=False, approved='APPROVED')
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            private=False,
+            approved='APPROVED'
+        )
         schedule.calculate_unscheduled()
         self.assertEqual([meeting], schedule.unscheduled)
 
     def test_calculate_unscheduled_ignores_scheduled_meetings(self):
         schedule = self.get_schedule(edit=True)
-        meeting = factory.make_one(Meeting, summit=schedule.summit, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            private=False
+        )
         room = factory.make_one(Room, summit=schedule.summit)
         slot = factory.make_one(Slot, summit=schedule.summit)
         meeting.agenda_set.create(room=room, slot=slot)
         schedule.calculate_unscheduled()
         self.assertEqual([], schedule.unscheduled)
 
-    def test_calculate_unscheduled_ignores_meetings_in_tracks_not_in_this_room(self):
+    def test_calculate_unscheduled_ignores_meetings_in_tracks_not_in_this_room(
+        self
+    ):
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='blueprint', private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='blueprint',
+            private=False
+        )
         track = factory.make_one(Track, summit=summit)
         other_track = factory.make_one(Track, summit=summit)
         room.tracks = [track]
@@ -1517,8 +2377,13 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='blueprint', private=False, approved='APPROVED')
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='blueprint',
+            private=False,
+            approved='APPROVED'
+        )
         track = factory.make_one(Track, summit=summit)
         room.tracks = [track]
         schedule.calculate_unscheduled()
@@ -1528,8 +2393,13 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='blueprint', private=False, approved='APPROVED')
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='blueprint',
+            private=False,
+            approved='APPROVED'
+        )
         track = factory.make_one(Track, summit=summit)
         meeting.tracks = [track]
         schedule.calculate_unscheduled()
@@ -1539,8 +2409,13 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='blueprint', private=False, approved='APPROVED')
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='blueprint',
+            private=False,
+            approved='APPROVED'
+        )
         track = factory.make_one(Track, summit=summit)
         meeting.tracks = [track]
         room.tracks = [track]
@@ -1551,8 +2426,13 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='blueprint', private=False, approved='APPROVED')
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='blueprint',
+            private=False,
+            approved='APPROVED'
+        )
         track = factory.make_one(Track, summit=summit)
         other_track = factory.make_one(Track, summit=summit)
         meeting.tracks = [track, other_track]
@@ -1564,8 +2444,12 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='plenary', private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='plenary',
+            private=False
+        )
         schedule.calculate_unscheduled()
         self.assertEqual([], schedule.unscheduled)
 
@@ -1573,8 +2457,12 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='talk', private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='talk',
+            private=False
+        )
         schedule.calculate_unscheduled()
         self.assertEqual([], schedule.unscheduled)
 
@@ -1582,8 +2470,12 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='open')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='special', private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='special',
+            private=False
+        )
         schedule.calculate_unscheduled()
         self.assertEqual([], schedule.unscheduled)
 
@@ -1591,8 +2483,13 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='plenary')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='plenary', private=False, approved='APPROVED')
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='plenary',
+            private=False,
+            approved='APPROVED'
+        )
         schedule.calculate_unscheduled()
         self.assertEqual([meeting], schedule.unscheduled)
 
@@ -1600,8 +2497,12 @@
         summit = factory.make_one(Summit)
         room = factory.make_one(Room, summit=summit, type='plenary')
         schedule = self.get_schedule(edit=True, room=room, summit=summit)
-        meeting = factory.make_one(Meeting, summit=schedule.summit,
-                type='blueprint', private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=schedule.summit,
+            type='blueprint',
+            private=False
+        )
         schedule.calculate_unscheduled()
         self.assertEqual([], schedule.unscheduled)
 
@@ -1609,16 +2510,38 @@
         now = datetime.datetime.utcnow()
         one_hour = datetime.timedelta(hours=1)
         summit = factory.make_one(
-            Summit, date_start=now.date(), date_end=now.date(),
-            timezone='UTC')
+            Summit,
+            date_start=now.date(),
+            date_end=now.date(),
+            timezone='UTC'
+        )
         slot = factory.make_one(
-            Slot, summit=summit, type='plenary',
-            start_utc=now-(2*one_hour), end_utc=now-(1*one_hour))
-        room1 = factory.make_one(Room, summit=summit, type='plenary', start_utc=now-(2*one_hour), end_utc=now-(1*one_hour))
-        room2 = factory.make_one(Room, summit=summit, type='plenary', start_utc=now-(2*one_hour), end_utc=now-(1*one_hour))
+            Slot,
+            summit=summit,
+            type='plenary',
+            start_utc=now-(2*one_hour),
+            end_utc=now-(1*one_hour)
+        )
+        room1 = factory.make_one(
+            Room,
+            summit=summit,
+            type='plenary',
+            start_utc=now-(2*one_hour),
+            end_utc=now-(1*one_hour)
+        )
+        room2 = factory.make_one(
+            Room,
+            summit=summit,
+            type='plenary',
+            start_utc=now-(2*one_hour),
+            end_utc=now-(1*one_hour)
+        )
         schedule = self.get_schedule(
-            edit=True, rooms=[room1, room2], summit=summit,
-            dates=[now.date()])
+            edit=True,
+            rooms=[room1, room2],
+            summit=summit,
+            dates=[now.date()]
+        )
         schedule.calculate()
         # To avoid test being fragile and arbitrarily dependent on the
         # room order, we check the returned schedule.meetings bit-by-bit.
@@ -1656,8 +2579,13 @@
             summit = factory.make_one(Summit)
         now = datetime.datetime.utcnow()
         one_hour = datetime.timedelta(hours=1)
-        return factory.make_one(Slot, summit=summit, start=now+one_hour,
-                end=now+one_hour+one_hour, type='open')
+        return factory.make_one(
+            Slot,
+            summit=summit,
+            start=now+one_hour,
+            end=now+one_hour+one_hour,
+            type='open'
+        )
 
     def test_update_meeting_skips_no_name(self):
         summit = factory.make_one(Summit)
@@ -1673,7 +2601,12 @@
         # Names are truncated at 100 chars.
         expected_name = "very " * 20
         self.assertEqual(expected_name, meeting.name)
-        self.assertEqual(1, summit.meeting_set.filter(name__exact=expected_name).count())
+        self.assertEqual(
+            1,
+            summit.meeting_set.filter(
+                name__exact=expected_name
+            ).count()
+        )
 
     def test_update_meeting_accepts_existing_meeting(self):
         summit = factory.make_one(Summit)
@@ -1683,7 +2616,13 @@
         summit.meeting_set.create(name=name, title=title)
         meeting = summit.update_meeting_from_launchpad(elem)
         self.assertEqual(name, meeting.name)
-        self.assertEqual(1, summit.meeting_set.filter(name__exact=name, title__exact=title).count())
+        self.assertEqual(
+            1,
+            summit.meeting_set.filter(
+                name__exact=name,
+                title__exact=title
+            ).count()
+        )
 
     def test_update_from_launchpad_response_empty(self):
         summit = factory.make_one(Summit)
@@ -1705,7 +2644,8 @@
         summit = factory.make_one(Summit, name='test-sprint')
         self.assertEqual(
             ['https://launchpad.net/sprints/test-sprint/+temp-meeting-export'],
-            summit.launchpad_sprint_import_urls())
+            summit.launchpad_sprint_import_urls()
+        )
 
     def test_launchpad_sprint_import_url_uses_one_summit_sprint(self):
         import_url = 'http://example.com/test'
@@ -1719,7 +2659,14 @@
         summit = factory.make_one(Summit)
         factory.make_one(SummitSprint, summit=summit, import_url=import_url1)
         factory.make_one(SummitSprint, summit=summit, import_url=import_url2)
-        self.assertEqual(sorted([import_url1, import_url2]), sorted(summit.launchpad_sprint_import_urls()))
+        self.assertEqual(
+            sorted(
+                [import_url1, import_url2]
+            ),
+            sorted(
+                summit.launchpad_sprint_import_urls()
+            )
+        )
 
     def test_update_from_launchpad_gets_info_for_all_import_urls(self):
         import_url1 = 'http://example.com/test1'
@@ -1728,57 +2675,105 @@
         factory.make_one(SummitSprint, summit=summit, import_url=import_url1)
         factory.make_one(SummitSprint, summit=summit, import_url=import_url2)
         called_urls = []
+
         def get_sprint_info(url):
             called_urls.append(url)
             return self.get_basic_launchpad_response()
+
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
-        self.assertEqual(sorted([import_url1, import_url2]), sorted(called_urls))
+        self.assertEqual(
+            sorted(
+                [import_url1, import_url2]
+            ),
+            sorted(called_urls)
+        )
 
     def test_update_from_launchpad_does_the_update(self):
         summit = factory.make_one(Summit)
+
         def get_sprint_info(url):
             elem = self.get_basic_launchpad_response()
             meeting_node = LaunchpadExportNode(name="foo", id="42")
             elem.find("unscheduled").add_child("meeting", meeting_node)
             return elem
+
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
         self.assertEqual(1, summit.meeting_set.all().count())
 
     def test_update_from_launchpad_does_renames(self):
         summit = factory.make_one(Summit)
-        meeting = summit.meeting_set.create(name="name", launchpad_blueprint_id="42")
+        meeting = summit.meeting_set.create(
+            name="name",
+            launchpad_blueprint_id="42"
+        )
+
         def get_sprint_info(url):
             elem = self.get_basic_launchpad_response()
             meeting_node = LaunchpadExportNode(name="other", id="42")
             elem.find("unscheduled").add_child("meeting", meeting_node)
             return elem
+
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
-        # Since both had blueprint id 42, it should just update the existing meeting
-        self.assertEqual(0, summit.meeting_set.filter(name__exact="name").count())
-        self.assertEqual(1, summit.meeting_set.filter(name__exact="other").count())
+        # Since both had blueprint id 42, it should just update
+        # the existing meeting
+        self.assertEqual(
+            0,
+            summit.meeting_set.filter(
+                name__exact="name"
+            ).count()
+        )
+        self.assertEqual(
+            1,
+            summit.meeting_set.filter(
+                name__exact="other"
+            ).count()
+        )
 
     def test_update_from_launchpad_deletes_missing_unscheduled_meetings(self):
         summit = factory.make_one(Summit)
-        meeting = summit.meeting_set.create(spec_url='test_url', name="name", launchpad_blueprint_id="42")
+        meeting = summit.meeting_set.create(
+            spec_url='test_url',
+            name="name",
+            launchpad_blueprint_id="42"
+        )
+
         def get_sprint_info(url):
             elem = self.get_basic_launchpad_response()
             meeting_node = LaunchpadExportNode(name="other")
             elem.find("unscheduled").add_child("meeting", meeting_node)
             return elem
+
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
-        self.assertEqual(1, summit.meeting_set.filter(name__exact="name").count())
-        self.assertEqual(0, summit.meeting_set.filter(name__exact="name").exclude(approved='REMOVED').count())
+        self.assertEqual(
+            1,
+            summit.meeting_set.filter(
+                name__exact="name"
+            ).count()
+        )
+        self.assertEqual(
+            0,
+            summit.meeting_set.filter(
+                name__exact="name"
+            ).exclude(
+                approved='REMOVED'
+            ).count()
+        )
 
     def test_update_from_launchpad_deletes_missing_scheduled_meetings(self):
         summit = factory.make_one(Summit)
-        meeting = summit.meeting_set.create(spec_url='test_url', name="name", launchpad_blueprint_id="42")
+        meeting = summit.meeting_set.create(
+            spec_url='test_url',
+            name="name",
+            launchpad_blueprint_id="42"
+        )
         room = factory.make_one(Room, summit=summit)
         slot = factory.make_one(Slot)
         agenda = meeting.agenda_set.create(room=room, slot=slot, auto=True)
+
         def get_sprint_info(url):
             elem = self.get_basic_launchpad_response()
             meeting_node = LaunchpadExportNode(name="other")
@@ -1786,12 +2781,29 @@
             return elem
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
-        self.assertEqual(1, summit.meeting_set.filter(name__exact="name").count())
-        self.assertEqual(0, summit.meeting_set.filter(name__exact="name").exclude(approved='REMOVED').count())
+        self.assertEqual(
+            1,
+            summit.meeting_set.filter(
+                name__exact="name"
+            ).count()
+        )
+        self.assertEqual(
+            0,
+            summit.meeting_set.filter(
+                name__exact="name"
+            ).exclude(
+                approved='REMOVED'
+            ).count()
+        )
 
     def test_update_from_launchpad_doesnt_delete_meetings_with_spec_url(self):
         summit = factory.make_one(Summit)
-        meeting = summit.meeting_set.create(spec_url='http://example.com/foo', name="name", launchpad_blueprint_id="42")
+        meeting = summit.meeting_set.create(
+            spec_url='http://example.com/foo',
+            name="name",
+            launchpad_blueprint_id="42"
+        )
+
         def get_sprint_info(url):
             elem = self.get_basic_launchpad_response()
             meeting_node = LaunchpadExportNode(name="other", id="43")
@@ -1799,25 +2811,43 @@
             return elem
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
-        self.assertEqual(1, summit.meeting_set.filter(name__exact="name").count())
+        self.assertEqual(
+            1,
+            summit.meeting_set.filter(
+                name__exact="name"
+            ).count()
+        )
 
-    def test_update_from_launchpad_doesnt_delete_meetings_with_no_spec_url(self):
+    def test_update_from_launchpad_wont_delete_meetings_without_spec_url(self):
         summit = factory.make_one(Summit)
-        meeting = summit.meeting_set.create(spec_url='', name="name", launchpad_blueprint_id="42")
+        meeting = summit.meeting_set.create(
+            spec_url='',
+            name="name",
+            launchpad_blueprint_id="42"
+        )
+
         def get_sprint_info(url):
             elem = self.get_basic_launchpad_response()
             meeting_node = LaunchpadExportNode(name="other", id="43")
             elem.find("unscheduled").add_child("meeting", meeting_node)
             return elem
+
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
-        self.assertEqual(1, summit.meeting_set.filter(name__exact="name").count())
+        self.assertEqual(
+            1,
+            summit.meeting_set.filter(
+                name__exact="name"
+            ).count()
+        )
 
     def test_update_from_launchpad_updates_last_update(self):
         old_now = datetime.datetime.utcnow() - datetime.timedelta(days=1)
         summit = factory.make_one(Summit, last_update=old_now)
+
         def get_sprint_info(url):
             return self.get_basic_launchpad_response()
+
         summit._get_sprint_info_from_launchpad = get_sprint_info
         summit.update_from_launchpad()
         self.assertTrue(old_now < summit.last_update)
@@ -1828,72 +2858,150 @@
 
     def test_reschedule_removes_missing_participants(self):
         summit = factory.make_one(Summit)
-        meeting1 = factory.make_one(Meeting, summit=summit,
-                requires_dial_in=False, private=False)
-        meeting2 = factory.make_one(Meeting, summit=summit,
-                requires_dial_in=False, private=False)
+        meeting1 = factory.make_one(
+            Meeting,
+            summit=summit,
+            requires_dial_in=False,
+            private=False
+        )
+        meeting2 = factory.make_one(
+            Meeting,
+            summit=summit,
+            requires_dial_in=False,
+            private=False
+        )
         room1 = factory.make_one(Room, summit=summit)
         room2 = factory.make_one(Room, summit=summit)
         slot = self.make_one_future_slot(summit=summit)
-        attendee = factory.make_one(Attendee, summit=summit,
-                start_utc=slot.start_utc, end_utc=slot.end_utc)
-        meeting1.participant_set.create(attendee=attendee, participation = 'REQUIRED')
-        meeting2.participant_set.create(attendee=attendee, participation = 'REQUIRED')
-        factory.make_one(Agenda, meeting=meeting1, room=room1, slot=slot,
-                auto=True)
-        factory.make_one(Agenda, meeting=meeting2, room=room2, slot=slot,
-                auto=True)
+        attendee = factory.make_one(
+            Attendee,
+            summit=summit,
+            start_utc=slot.start_utc,
+            end_utc=slot.end_utc
+        )
+        meeting1.participant_set.create(
+            attendee=attendee,
+            participation='REQUIRED'
+        )
+        meeting2.participant_set.create(
+            attendee=attendee,
+            participation='REQUIRED'
+        )
+        factory.make_one(
+            Agenda,
+            meeting=meeting1,
+            room=room1,
+            slot=slot,
+            auto=True
+        )
+        factory.make_one(
+            Agenda,
+            meeting=meeting2,
+            room=room2,
+            slot=slot,
+            auto=True
+        )
         summit.reschedule()
         self.assertEqual(1, slot.agenda_set.all().count())
 
     def test_reschedule_removes_unavailable_participants(self):
         summit = factory.make_one(Summit)
-        meeting = factory.make_one(Meeting, summit=summit,
-                requires_dial_in=False, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            requires_dial_in=False,
+            private=False
+        )
         room = factory.make_one(Room, summit=summit)
         slot = self.make_one_future_slot(summit=summit)
-        attendee = factory.make_one(Attendee, summit=summit,
-                start_utc=slot.end_utc,
-                end_utc=slot.end_utc+datetime.timedelta(hours=1))
-        meeting.participant_set.create(attendee=attendee, participation = 'REQUIRED')
-        factory.make_one(Agenda, meeting=meeting, room=room, slot=slot,
-                auto=True)
+        attendee = factory.make_one(
+            Attendee,
+            summit=summit,
+            start_utc=slot.end_utc,
+            end_utc=slot.end_utc+datetime.timedelta(hours=1)
+        )
+        meeting.participant_set.create(
+            attendee=attendee,
+            participation='REQUIRED'
+        )
+        factory.make_one(
+            Agenda,
+            meeting=meeting,
+            room=room,
+            slot=slot,
+            auto=True
+        )
         summit.reschedule()
         self.assertEqual(0, slot.agenda_set.all().count())
 
     def test_reschedule_removes_insufficient_slots(self):
         summit = factory.make_one(Summit)
-        meeting = factory.make_one(Meeting, summit=summit, slots=2,
-                requires_dial_in=False, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            slots=2,
+            requires_dial_in=False,
+            private=False
+        )
         room = factory.make_one(Room, summit=summit)
         slot = self.make_one_future_slot(summit=summit)
-        factory.make_one(Agenda, meeting=meeting, room=room, slot=slot,
-                auto=True)
+        factory.make_one(
+            Agenda,
+            meeting=meeting,
+            room=room,
+            slot=slot,
+            auto=True
+        )
         summit.reschedule()
         self.assertEqual(0, slot.agenda_set.all().count())
 
     def test_reschedule_leaves_old_slots(self):
         summit = factory.make_one(Summit)
-        meeting = factory.make_one(Meeting, summit=summit, slots=2,
-                requires_dial_in=False, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            slots=2,
+            requires_dial_in=False,
+            private=False
+        )
         room = factory.make_one(Room, summit=summit)
         now = datetime.datetime.utcnow()
         one_hour = datetime.timedelta(hours=1)
-        slot = factory.make_one(Slot, summit=summit, start=now-one_hour,
-                end=now, type='open')
-        factory.make_one(Agenda, meeting=meeting, room=room, slot=slot,
-                auto=True)
+        slot = factory.make_one(
+            Slot,
+            summit=summit,
+            start=now-one_hour,
+            end=now,
+            type='open'
+        )
+        factory.make_one(
+            Agenda,
+            meeting=meeting,
+            room=room,
+            slot=slot,
+            auto=True
+        )
         summit.reschedule()
         self.assertEqual(1, slot.agenda_set.all().count())
 
     def test_reschedule_leaves_manually_scheduled(self):
         summit = factory.make_one(Summit)
-        meeting = factory.make_one(Meeting, summit=summit, slots=2,
-                requires_dial_in=False, private=False)
+        meeting = factory.make_one(
+            Meeting,
+            summit=summit,
+            slots=2,
+            requires_dial_in=False,
+            private=False
+        )
         room = factory.make_one(Room, summit=summit)
         slot = self.make_one_future_slot(summit=summit)
-        factory.make_one(Agenda, meeting=meeting, room=room, slot=slot,
-                auto=False)
+        factory.make_one(
+            Agenda,
+            meeting=meeting,
+            room=room,
+            slot=slot,
+            auto=False
+        )
         summit.reschedule()
         self.assertEqual(1, slot.agenda_set.all().count())
 
@@ -1909,40 +3017,66 @@
         attendee_node = LaunchpadExportNode(name='testuser')
         summit.update_attendee_from_launchpad(attendee_node)
 
-        self.assertEqual(1, summit.attendee_set.filter(user__username__exact="testuser").count())
+        self.assertEqual(
+            1,
+            summit.attendee_set.filter(
+                user__username__exact="testuser"
+            ).count()
+        )
         self.assertTrue(mock_set_openid.called)
 
+
 class DeleteMeetingTestCase(djangotest.TestCase):
     """
     This will test different options for deleting a meeting from
     the front end UI.
     """
- 
+
     def setUp(self):
         now = datetime.datetime.utcnow()
         one_hour = datetime.timedelta(0, 3600)
-        self.summit = factory.make_one(Summit, name='uds-test', date_start=now, date_end=now+one_hour)
+        self.summit = factory.make_one(
+            Summit,
+            name='uds-test',
+            date_start=now,
+            date_end=now+one_hour
+        )
         self.summit.save()
         slot = factory.make_one(
             Slot,
             summit=self.summit,
             start_utc=now,
-            end_utc=now+one_hour)
+            end_utc=now+one_hour
+        )
         room = factory.make_one(Room)
- 
-        self.meeting = factory.make_one(Meeting, summit=self.summit, requires_dial_in=False, private=False)
- 
+
+        self.meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            requires_dial_in=False,
+            private=False
+        )
+
         attendee1 = factory.make_one(Attendee)
         factory.make_one(Participant, meeting=self.meeting, attendee=attendee1)
- 
+
         factory.make_one(Agenda, meeting=self.meeting, slot=slot, room=room)
-        
-        self.user = factory.make_one(User, username='testuser', is_active=True, is_superuser=False)
+
+        self.user = factory.make_one(
+            User,
+            username='testuser',
+            is_active=True,
+            is_superuser=False
+        )
         self.user.set_password('password')
         self.user.save()
- 
-        self.attendee = factory.make_one(Attendee, user=self.user, summit=self.summit)
- 
+
+        self.attendee = factory.make_one(
+            Attendee,
+            user=self.user,
+            summit=self.summit
+        )
+
     def tearDown(self):
         self.client.logout()
         self.user.user_permissions.all().delete()
@@ -1950,39 +3084,109 @@
     def login(self):
         logged_in = self.client.login(username='testuser', password='password')
         self.assertTrue(logged_in)
- 
+
     def test_track_lead_cant_delete_meeting(self):
-        self.lead = factory.make_one(Lead, lead=self.attendee, summit=self.summit)
+        self.lead = factory.make_one(
+            Lead,
+            lead=self.attendee,
+            summit=self.summit
+        )
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.delete_meeting', args=(self.summit, self.meeting.id, self.meeting.name)))
-        self.assertRedirects(response, reverse('summit.schedule.views.summit', args=(self.summit.name,)), status_code=302, target_status_code=200)
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.delete_meeting',
+                args=(self.summit, self.meeting.id, self.meeting.name)
+            )
+        )
+        self.assertRedirects(
+            response,
+            reverse(
+                'summit.schedule.views.summit',
+                args=(self.summit.name,)
+            ),
+            status_code=302,
+            target_status_code=200
+        )
 
     def test_user_cant_delete_meeting(self):
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.delete_meeting', args=(self.summit, self.meeting.id, self.meeting.name)))
-        self.assertRedirects(response, reverse('summit.schedule.views.summit', args=(self.summit.name,)), status_code=302, target_status_code=200)
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.delete_meeting',
+                args=(self.summit, self.meeting.id, self.meeting.name)
+            )
+        )
+        self.assertRedirects(
+            response,
+            reverse(
+                'summit.schedule.views.summit',
+                args=(self.summit.name,)
+            ),
+            status_code=302,
+            target_status_code=200
+        )
 
     def test_managers_cant_delete_meeting(self):
         self.summit.managers.add(self.user)
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.delete_meeting', args=(self.summit, self.meeting.id, self.meeting.name)))
-        self.assertRedirects(response, reverse('summit.schedule.views.summit', args=(self.summit.name,)), status_code=302, target_status_code=200)
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.delete_meeting',
+                args=(self.summit, self.meeting.id, self.meeting.name)
+            )
+        )
+        self.assertRedirects(
+            response,
+            reverse(
+                'summit.schedule.views.summit',
+                args=(self.summit.name,)
+            ),
+            status_code=302,
+            target_status_code=200
+        )
 
     def test_schedulers_can_delete_meeting(self):
         self.summit.schedulers.add(self.user)
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.delete_meeting', args=(self.summit, self.meeting.id, self.meeting.name)))
-        self.assertRedirects(response, reverse('summit.schedule.views.delete_confirmed', args=(self.summit.name,)), status_code=302, target_status_code=200)
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.delete_meeting',
+                args=(self.summit, self.meeting.id, self.meeting.name)
+            )
+        )
+        self.assertRedirects(
+            response,
+            reverse(
+                'summit.schedule.views.delete_confirmed',
+                args=(self.summit.name,)
+            ),
+            status_code=302,
+            target_status_code=200
+        )
 
     def test_change_agenda_can_delete_meeting(self):
         """
-        Testing if a user who is assigned can_change_agenda in django admin can delete a meeting
+        Testing if a user who is assigned can_change_agenda
+        in django admin can delete a meeting
         """
         change_agenda = Permission.objects.get(codename='change_agenda')
         self.user.user_permissions.add(change_agenda)
         self.login()
-        response = self.client.get(reverse('summit.schedule.views.delete_meeting', args=(self.summit, self.meeting.id, self.meeting.name)))
-        self.assertRedirects(response, reverse('summit.schedule.views.delete_confirmed', args=(self.summit.name,)), status_code=302, target_status_code=200)
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.delete_meeting',
+                args=(self.summit, self.meeting.id, self.meeting.name)
+            )
+        )
+        self.assertRedirects(
+            response,
+            reverse(
+                'summit.schedule.views.delete_confirmed',
+                args=(self.summit.name,)
+            ),
+            status_code=302,
+            target_status_code=200
+        )
 
 
 class MeetingSearchTestCase(djangotest.TestCase):
@@ -1990,79 +3194,182 @@
     This will test different options for deleting a meeting from
     the front end UI.
     """
- 
+
     form_html = '<form id="site_search_form"'
-    
+
     def setUp(self):
         now = datetime.datetime.utcnow()
         one_hour = datetime.timedelta(0, 3600)
-        self.summit = factory.make_one(Summit, name='uds-test', date_start=now, date_end=now+one_hour)
+        self.summit = factory.make_one(
+            Summit,
+            name='uds-test',
+            date_start=now,
+            date_end=now+one_hour
+        )
         self.slot = factory.make_one(
             Slot,
             summit=self.summit,
             start_utc=now,
-            end_utc=now+one_hour)
+            end_utc=now+one_hour
+        )
         self.room = factory.make_one(Room)
-  
+
+    def tearDown(self):
+        pass
+
     def test_searchform_exists_on_summit_view(self):
         ''' Search form should appear on the summit view page '''
-        response = self.client.get(reverse('summit.schedule.views.summit', args=[self.summit.name]))
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.summit',
+                args=[self.summit.name]
+            )
+        )
         self.assertContains(response, self.form_html, 1)
-    
+
     def test_searchform_exists_on_daily_view(self):
         ''' Search form should appear on the list view page '''
-        response = self.client.get(reverse('summit.schedule.views.daily_schedule', args=[self.summit.name, '2012-10-10']))
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.daily_schedule',
+                args=[self.summit.name, '2012-10-10']
+            )
+        )
         self.assertContains(response, self.form_html, 1)
-    
+
     def test_searchform_exists_on_today_view(self):
         ''' Search form should appear on the today view page '''
-        response = self.client.get(reverse('summit.schedule.views.today_view', args=[self.summit.name]))
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.today_view',
+                args=[self.summit.name]
+            )
+        )
         self.assertContains(response, self.form_html, 1)
-    
+
     def test_searchform_exists_on_meeting_view(self):
         ''' Search form should appear on the meeting view page '''
-        meeting = factory.make_one(Meeting, summit=self.summit, requires_dial_in=False, private=False)
- 
-        response = self.client.get(reverse('summit.schedule.views.meeting', args=[self.summit.name, meeting.id, meeting.name]))
+        meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            requires_dial_in=False,
+            private=False
+        )
+
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.meeting',
+                args=[self.summit.name, meeting.id, meeting.name]
+            )
+        )
         self.assertContains(response, self.form_html, 1)
-    
+
     def test_searchform_not_exists_on_index(self):
-        ''' Search form should NOT appear on the index page because there isn't a summit selected  '''
+        '''
+        Search form should NOT appear on the index page because
+        there isn't a summit selected
+        '''
         response = self.client.get(reverse('summit.common.views.index'))
         self.assertContains(response, self.form_html, 0)
-    
+
     def test_meeting_in_search_results(self):
-        ''' Meeting should appear in search results page if the query matches the name or title '''
-        meeting = factory.make_one(Meeting, summit=self.summit, name='test-name', title='Test Title', requires_dial_in=False, private=False)
+        '''
+        Meeting should appear in search results page if the query
+        matches the name or title
+        '''
+        meeting = factory.make_one(
+            Meeting,
+            summit=self.summit,
+            name='test-name',
+            title='Test Title',
+            requires_dial_in=False,
+            private=False
+        )
 
         # Attempt to match 'name' against 'test-name' in Meeting.name
-        response = self.client.get(reverse('summit.schedule.views.search', args=[self.summit.name]), {'q': 'name'})
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.search',
+                args=[self.summit.name]
+            ),
+            {'q': 'name'}
+        )
         self.assertContains(response, self.form_html, 1)
-        self.assertContains(response, '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(), 1)
-    
+        self.assertContains(
+            response,
+            '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(),
+            1
+        )
+
         # Attempt to match 'title' against 'Test Title' in Meeting.title
-        response = self.client.get(reverse('summit.schedule.views.search', args=[self.summit.name]), {'q': 'title'})
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.search',
+                args=[self.summit.name]
+            ),
+            {'q': 'title'}
+        )
         self.assertContains(response, self.form_html, 1)
-        self.assertContains(response, '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(), 1)
-    
+        self.assertContains(
+            response,
+            '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(),
+            1
+        )
+
     def test_meeting_not_in_search_results(self):
-        ''' Meetings for one summit should NOT appear when searching a different summit '''
+        '''
+        Meetings for one summit should NOT appear when searching
+        a different summit
+        '''
         now = datetime.datetime.utcnow()
         one_hour = datetime.timedelta(0, 3600)
-        
+
         # Create a second summit
-        other_summit = factory.make_one(Summit, name='uds-other', date_start=now, date_end=now+one_hour)
-
-        meeting = factory.make_one(Meeting, summit=other_summit, name='test-name', title='Test Title', requires_dial_in=False, private=False)
-
-        # Attempt to match 'test' against 'test-name' or 'Test Title', should return 0 results
-        # because the the meeting is in other_summit, not self.summit
-        response = self.client.get(reverse('summit.schedule.views.search', args=[self.summit.name]), {'q': 'test'})
-        self.assertContains(response, self.form_html, 1)
-        self.assertContains(response, '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(), 0)
-        
-        # Same test, but searching the correct other_summit should return 1 result
-        response = self.client.get(reverse('summit.schedule.views.search', args=[other_summit.name]), {'q': 'test'})
-        self.assertContains(response, self.form_html, 1)
-        self.assertContains(response, '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(), 1)
-        
+        other_summit = factory.make_one(
+            Summit,
+            name='uds-other',
+            date_start=now,
+            date_end=now+one_hour
+        )
+
+        meeting = factory.make_one(
+            Meeting,
+            summit=other_summit,
+            name='test-name',
+            title='Test Title',
+            requires_dial_in=False,
+            private=False
+        )
+
+        # Attempt to match 'test' against 'test-name' or 'Test Title'
+        # should return 0 results because the the meeting is in
+        # other_summit, not self.summit
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.search',
+                args=[self.summit.name]
+            ),
+            {'q': 'test'}
+        )
+        self.assertContains(response, self.form_html, 1)
+        self.assertContains(
+            response,
+            '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(),
+            0
+        )
+
+        # Same test, but searching the correct other_summit should return
+        # 1 result
+        response = self.client.get(
+            reverse(
+                'summit.schedule.views.search',
+                args=[other_summit.name]
+            ),
+            {'q': 'test'}
+        )
+        self.assertContains(response, self.form_html, 1)
+        self.assertContains(
+            response,
+            '<a href="%s">Test Title</a>' % meeting.get_meeting_page_url(),
+            1
+        )