def testAccessToTheList(self):
    """Tests only the host can access the list."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBStudent(self.program, user=user)

    response = self.get(self.url)
    self.assertResponseForbidden(response)

    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user,
        mentor_for=[ndb.Key.from_old_key(self.org.key())])

    response = self.get(self.url)
    self.assertResponseForbidden(response)

    # check for an organization administrator
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user,
        admin_for=[ndb.Key.from_old_key(self.org.key())])

    response = self.get(self.url)
    self.assertResponseForbidden(response)

    user = profile_utils.seedNDBUser(host_for=[self.program])
    profile_utils.loginNDB(user)
    response = self.get(self.url)
    self.assertResponseOK(response)

  def testPostButtonExtendDeadline(self):
    """Tests the extend deadline button."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user,
        mentor_for=[ndb.Key.from_old_key(self.org.key())])

    student = profile_utils.seedNDBStudent(self.program)

    # set it in the future so that the auto state transfer doesn't trigger
    deadline = datetime.datetime.utcnow() + datetime.timedelta(hours=24)

    self.task.status = 'Claimed'
    self.task.student = student.key.to_old_key()
    self.task.deadline = deadline
    self.task.put()

    url = _taskPageURL(self.task)
    response = self.buttonPost(
        url, 'button_extend_deadline', {'hours': 1})

    task = task_model.GCITask.get(self.task.key())
    self.assertResponseRedirect(response)

    delta = task.deadline - deadline
    self.assertTrue(delta.seconds == 3600)

    # check if a comment has been created
    comments = self.task.comments()
    self.assertEqual(len(comments), 1)
    self.assertMailSentToSubscribers(comments[0])

    self.assertBasicTaskView()

  def testPostButtonUnassign(self):
    """Tests the unassign button."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user,
        mentor_for=[ndb.Key.from_old_key(self.org.key())])

    student = profile_utils.seedNDBStudent(self.program)

    self.task.status = 'Claimed'
    self.task.student = student.key.to_old_key()
    self.task.put()

    url = _taskPageURL(self.task)
    response = self.buttonPost(url, 'button_unassign')

    # check if the task is properly unassigned
    task = task_model.GCITask.get(self.task.key())
    self.assertResponseRedirect(response)
    self.assertEqual(task.status, task_model.REOPENED)
    self.assertIsNone(task.student)
    self.assertIsNone(task.deadline)

    # check if a comment has been created
    comments = self.task.comments()
    self.assertEqual(len(comments), 1)
    self.assertMailSentToSubscribers(comments[0])

    self.assertBasicTaskView()

  def testPostButtonNeedsWork(self):
    """Tests the needs more work for task button."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user,
        mentor_for=[ndb.Key.from_old_key(self.org.key())])

    student = profile_utils.seedNDBStudent(self.program)

    self.task.status = 'NeedsReview'
    self.task.student = student.key.to_old_key()
    self.task.put()

    url = _taskPageURL(self.task)
    response = self.buttonPost(url, 'button_needs_work')

    # check if the task is properly closed
    task = task_model.GCITask.get(self.task.key())
    self.assertResponseRedirect(response)
    self.assertEqual(task.status, 'NeedsWork')
    self.assertEqual(
        task_model.GCITask.student.get_value_for_datastore(task),
        student.key.to_old_key())
    self.assertIsNone(task.deadline)

    # check if a comment has been created
    comments = self.task.comments()
    self.assertEqual(len(comments), 1)
    self.assertMailSentToSubscribers(comments[0])

    self.assertBasicTaskView()

  def testOrgAppCreateOrEditByMentor(self):
    """Tests that a mentor cannot create an organization application.
    """
    # Make sure we do not have an org app for this test.
    self.org_app.delete()

    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user, mentor_for=[self.org.key])

    url = '/gsoc/org/application/edit/' + self.gsoc.key().name()
    response = self.get(url)
    self.assertResponseForbidden(response)

    org_app_key_name = 'gsoc_program/%s/orgapp' % (self.gsoc.key().name(),)
    org_app = org_app_survey.OrgAppSurvey.get_by_key_name(org_app_key_name)

    self.assertIsNone(org_app)

    response = self.post(url, self.getOrgAppCreatePostData())
    self.assertResponseForbidden(response)

    org_app = org_app_survey.OrgAppSurvey.get_by_key_name(org_app_key_name)
    self.assertIsNone(org_app)

  def testPostButtonAssign(self):
    """Tests the assign button."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user,
        mentor_for=[ndb.Key.from_old_key(self.org.key())])

    student = profile_utils.seedNDBStudent(self.program)

    self.task.status = 'ClaimRequested'
    self.task.student = student.key.to_old_key()
    self.task.put()

    url = _taskPageURL(self.task)
    response = self.buttonPost(url, 'button_assign')

    # check if the task is properly assigned and a deadline has been set
    task = task_model.GCITask.get(self.task.key())
    self.assertResponseRedirect(response)
    self.assertEqual(task.status, 'Claimed')
    self.assertEqual(
        task_model.GCITask.student.get_value_for_datastore(task),
        student.key.to_old_key())
    self.assertTrue(task.deadline)

    # check if a comment has been created
    comments = self.task.comments()
    self.assertEqual(len(comments), 1)
    self.assertMailSentToSubscribers(comments[0])

    # check if the update task has been enqueued
    self.assertTasksInQueue(n=1, url=_taskUpdateURL(task))

    self.assertBasicTaskView()

  def testEmailIsSent(self):
    """Tests that acceptance and rejection emails are sent."""
    # seed a couple of organization administrators for both organizations
    addresses_for_accept_email = []
    addresses_for_reject_email = []
    for _ in range(_NUMBER_OF_ORG_ADMINS):
      profile = profile_utils.seedNDBProfile(
          self.program.key(), admin_for=[self.pre_accepted_org.key])
      addresses_for_accept_email.append(profile.contact.email)

      profile = profile_utils.seedNDBProfile(
          self.program.key(), admin_for=[self.pre_rejected_org.key])
      addresses_for_reject_email.append(profile.contact.email)

    # finalize decision and execute all MapReduce jobs
    kwargs = {
        'sponsor': self.sponsor.key().name(),
        'program': self.program.program_id,
        }
    request = http.HttpRequest()
    data = request_data.RequestData(request, None, kwargs)

    handler = org_app_view.ApplyOrgAdmissionDecisionHandler(_MockView())
    handler.handle(data, None, None)

    self.executeMapReduceJobs()

    # check that emails have been sent
    for email_address in addresses_for_accept_email:
      self.assertEmailSent(bcc=email_address)

    for email_address in addresses_for_reject_email:
      self.assertEmailSent(bcc=email_address)

  def testForNonStudentProfile(self):
    """Tests that True is returned if a non-student profile exists."""
    # seed a non-student profile
    profile_utils.seedNDBProfile(self.program.key(), user=self.user)

    result = validate.hasNonStudentProfileForProgram(
        self.user.key, self.program.key())
    self.assertTrue(result)

  def testPageLoads(self):
    """Tests that the page loads properly."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(self.program.key(), user=user)

    response = self.get(_getPickOrganizationToConnectUrl(self.program))
    self.assertResponseOK(response)

  def testUserWithActiveProfileAccessGranted(self):
    """Tests that access is granted if the user has an active profile."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(self.program.key(), user=user)

    access_checker = access.HAS_PROFILE_ACCESS_CHECKER
    access_checker.checkAccess(self.data, None)

 def setUp(self):
   """See unittest.TestCase.setUp for specification."""
   program = program_utils.seedProgram()
   profile = profile_utils.seedNDBProfile(program.key())
   org = org_utils.seedOrganization(program.key())
   self.connection = connection_utils.seed_new_connection(profile.key, org.key)
   self.org_admin = profile_utils.seedNDBProfile(
       program.key(), admin_for=[org.key])

  def testPageLoads(self):
    """Tests that the page loads properly."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(self.program.key(), user=user)

    response = self.get(_getNotificationSettingsUrl(self.program.key()))
    self.assertResponseOK(response)

  def testUserWithNonStudentProfileAccessGranted(self):
    """Tests that access is granted if current user has non-student profile."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(self.program.key(), user=user)

    access_checker = access.NON_STUDENT_PROFILE_ACCESS_CHECKER
    access_checker.checkAccess(self.data, None)

  def testPageLoads(self):
    """Tests that page loads properly."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(self.program.key(), user=user)

    response = self.get(_getOrgProfileCreateUrl(self.program))
    self.assertResponseOK(response)

  def testOrgAdminAccessForbidden(self):
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    self._assertAccessForbiddenForUrl(self._getEnrollmentFormUrl())
    self._assertAccessForbiddenForUrl(self._getTaxFormUrl())

  def testGetMethodForbidden(self):
    """Tests that GET method is not permitted."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    response = self.get(_getMarkAsSeenByOrgUrl(self.connection))
    self.assertResponseForbidden(response)

  def testForNonActiveProfile(self):
    """Tests that False is returned if a profile is not active."""
    # seed a non-student, banned profile
    profile_utils.seedNDBProfile(
        self.program.key(), user=self.user, status=profile_model.Status.BANNED)

    result = validate.hasNonStudentProfileForProgram(
        self.user.key, self.program.key())
    self.assertFalse(result)

  def testProfileExists(self):
    """Tests that second profile is not created for same user and program."""
    # seed a profile
    profile_utils.seedNDBProfile(self.program.key(), user=self.user)

    result = profile_logic.createProfile(
        self.user.key, self.program.key(), TEST_PROFILE_PROPERTIES)
    self.assertFalse(result)
    self.assertEqual(result.extra, profile_logic.PROFILE_EXISTS)

  def testDashboardAsLoneUser(self):
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(self.program.key(), user=user)

    url = '/gsoc/dashboard/' + self.gsoc.key().name()
    response = self.get(url)
    self.assertResponseOK(response)
    self.assertDashboardTemplatesUsed(response)

  def testOrgAdminAccessDenied(self):
    """Tests that org admins cannot access the page."""
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    profile_utils.seedNDBProfile(
        self.program.key(), user=user, admin_for=[self.org.key])

    response = self.get(self._getUrl())
    self.assertResponseForbidden(response)