Пример #1
0
    def setUp(self):
        sponsor = program_utils.seedSponsor()

        # seed a timeline and set student app period for now
        self.timeline = program_utils.seedTimeline(
            models=types.SOC_MODELS,
            timeline_id=TEST_PROGRAM_ID,
            sponsor_key=sponsor.key(),
            student_signup_start=timeline_utils.past(),
            student_signup_end=timeline_utils.future(delta=50),
            accepted_students_announced_deadline=timeline_utils.future(
                delta=75))

        self.program = program_utils.seedGSoCProgram(
            program_id=TEST_PROGRAM_ID,
            sponsor_key=sponsor.key(),
            timeline_key=self.timeline.key(),
            app_tasks_limit=3)

        # seed a new student info
        self.student = profile_utils.seedNDBStudent(self.program)

        # seed a new proposal
        self.proposal = proposal_utils.seedProposal(
            self.student.key,
            self.program.key(),
            status=proposal_model.STATUS_WITHDRAWN)
Пример #2
0
  def setUp(self):
    """See unittest.setUp for specification."""
    sponsor = program_utils.seedSponsor()
    self.program = program_utils.seedProgram(sponsor_key=sponsor.key())

    self.kwargs = {
        'sponsor': sponsor.key().name(),
        'program': self.program.program_id,
        }
Пример #3
0
    def setUp(self):
        """See unittest.setUp for specification."""
        sponsor = program_utils.seedSponsor()
        self.program = program_utils.seedProgram(sponsor_key=sponsor.key())

        self.kwargs = {
            'sponsor': sponsor.key().name(),
            'program': self.program.program_id,
        }
Пример #4
0
 def setUp(self):
   sponsor = program_utils.seedSponsor()
   program = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
   org_app = program_utils.seedApplicationSurvey(program.key())
   timeline_test_helper = timeline_utils.GSoCTimelineHelper(
       program.timeline, org_app)
   timeline_test_helper.orgSignup()
   self.timeline_helper = request_data.TimelineHelper(
       program.timeline, org_app)
Пример #5
0
 def setUp(self):
     sponsor = program_utils.seedSponsor()
     program = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
     org_app = program_utils.seedApplicationSurvey(program.key())
     timeline_test_helper = timeline_utils.GSoCTimelineHelper(
         program.timeline, org_app)
     timeline_test_helper.orgSignup()
     self.timeline_helper = request_data.TimelineHelper(
         program.timeline, org_app)
Пример #6
0
 def init(self):
     """Performs test set-up by seeding data and setting attributes."""
     super(GSoCTestCase, self).init()
     self.sponsor = program_utils.seedSponsor()
     self.program = self.gsoc = program_utils.seedGSoCProgram(sponsor_key=self.sponsor.key())
     self.program_helper = program_utils.GSoCProgramHelper(sponsor=self.sponsor, program=self.program)
     self.site = program_utils.seedSite(active_program=self.program)
     self.org = self.program_helper.createOrg()
     self.org_app = self.program_helper.createOrgApp()
     self.timeline_helper = timeline_utils.GSoCTimelineHelper(self.gsoc.timeline, self.org_app)
Пример #7
0
  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    sponsor = program_utils.seedSponsor()
    self.program = program_utils.seedProgram(sponsor_key=sponsor.key())

    kwargs = {
        'sponsor': sponsor.key().name(),
        'program': self.program.program_id,
        }
    self.data = request_data.RequestData(None, None, kwargs)
Пример #8
0
    def setUp(self):
        """See unittest.TestCase.setUp for specification."""
        sponsor = program_utils.seedSponsor()
        self.program = program_utils.seedProgram(sponsor_key=sponsor.key())

        kwargs = {
            'sponsor': sponsor.key().name(),
            'program': self.program.program_id
        }
        self.data = request_data.RequestData(None, None, kwargs)
 def createGCIProgram(self):
   """Create GCI Program."""
   self.program_helper = program_utils.GCIProgramHelper()
   self.gci = self.program = self.program_helper.createProgram(override={'name':'Google Code In',
     'short_name':'gci'})
   self.program = self.gci.key().name()
   self.org = self.program_helper.createOrg()
   self.org_app = self.program_helper.createOrgApp()
   self.user = profile_utils.seedNDBProfile(self.gci.key())
   self.sponsor = program_utils.seedSponsor(sponsor_id='google')
   self.site = program_utils.seedSite(latest_gci=self.sponsor.key().name() + '/' + self.program, active_program=self.gci)
Пример #10
0
 def init(self):
     """Performs test set-up by seeding data and setting attributes."""
     super(GSoCTestCase, self).init()
     self.sponsor = program_utils.seedSponsor()
     self.program = self.gsoc = program_utils.seedGSoCProgram(
         sponsor_key=self.sponsor.key())
     self.program_helper = program_utils.GSoCProgramHelper(
         sponsor=self.sponsor, program=self.program)
     self.site = program_utils.seedSite(active_program=self.program)
     self.org = self.program_helper.createOrg()
     self.org_app = self.program_helper.createOrgApp()
     self.timeline_helper = timeline_utils.GSoCTimelineHelper(
         self.gsoc.timeline, self.org_app)
Пример #11
0
  def testProfileExists(self):
    """Tests that profile is returned correctly if exists."""
    sponsor = program_utils.seedSponsor()
    program = program_utils.seedProgram(sponsor_key=sponsor.key())
    profile = profile_utils.seedNDBProfile(program.key())

    kwargs = {
        'sponsor': sponsor.link_id,
        'program': program.program_id,
        'user': profile.profile_id,
        }
    data = request_data.RequestData(None, None, kwargs)
    url_profile = data.url_ndb_profile
    self.assertEqual(profile.key, url_profile.key)
Пример #12
0
  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    self.sponsor = program_utils.seedSponsor()
    self.program = program_utils.seedProgram(sponsor_key=self.sponsor.key())

    # seed a user who will be tested for access
    self.user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(self.user)

    kwargs = {
        'sponsor': self.sponsor.key().name(),
        'program': self.program.program_id,
        }
    self.data = request_data.RequestData(None, None, kwargs)
Пример #13
0
  def testForNonHostUser(self):
    """Tests that False is returned for a user who is not a host."""
    sponsor = program_utils.seedSponsor()
    program = program_utils.seedProgram(sponsor_key=sponsor.key())
    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)

    kwargs = {
        'sponsor': sponsor.link_id,
        'program': program.program_id,
        }
    data = request_data.RequestData(None, None, kwargs)
    is_host = data.is_host
    self.assertFalse(is_host)
Пример #14
0
    def testProfileExists(self):
        """Tests that profile is returned correctly if exists."""
        sponsor = program_utils.seedSponsor()
        program = program_utils.seedProgram(sponsor_key=sponsor.key())
        profile = profile_utils.seedNDBProfile(program.key())

        kwargs = {
            'sponsor': sponsor.link_id,
            'program': program.program_id,
            'user': profile.profile_id,
        }
        data = request_data.RequestData(None, None, kwargs)
        url_profile = data.url_ndb_profile
        self.assertEqual(profile.key, url_profile.key)
Пример #15
0
    def testForNonHostUser(self):
        """Tests that False is returned for a user who is not a host."""
        sponsor = program_utils.seedSponsor()
        program = program_utils.seedProgram(sponsor_key=sponsor.key())
        user = profile_utils.seedNDBUser()
        profile_utils.loginNDB(user)

        kwargs = {
            'sponsor': sponsor.link_id,
            'program': program.program_id,
        }
        data = request_data.RequestData(None, None, kwargs)
        is_host = data.is_host
        self.assertFalse(is_host)
Пример #16
0
  def setUp(self):
    sponsor = program_utils.seedSponsor()

    # seed a timeline and set student app period for now
    self.timeline = program_utils.seedTimeline(
        models=types.SOC_MODELS, timeline_id=TEST_PROGRAM_ID,
        sponsor_key=sponsor.key(), student_signup_start=timeline_utils.past(),
        student_signup_end=timeline_utils.future())

    self.program = program_utils.seedGSoCProgram(
        program_id=TEST_PROGRAM_ID, sponsor_key=sponsor.key(),
        timeline_key=self.timeline.key(), app_tasks_limit=3)

    self.student = profile_utils.seedNDBStudent(self.program)
Пример #17
0
    def setUp(self):
        """See unittest.TestCase.setUp for specification."""
        self.sponsor = program_utils.seedSponsor()
        self.program = program_utils.seedProgram(
            sponsor_key=self.sponsor.key())

        # seed a user who will be tested for access
        self.user = profile_utils.seedNDBUser()
        profile_utils.loginNDB(self.user)

        kwargs = {
            'sponsor': self.sponsor.key().name(),
            'program': self.program.program_id,
        }
        self.data = request_data.RequestData(None, None, kwargs)
Пример #18
0
 def createGSoCProgram(self):
     """Create GSoC Program."""
     self.program_helper = program_utils.GSoCProgramHelper()
     self.gsoc = self.program_helper.createProgram(override={
         'name': 'Google Summer of Code',
         'short_name': 'gsoc'
     })
     self.program = self.gsoc.key().name()
     self.org = self.program_helper.createOrg()
     self.org_app = self.program_helper.createOrgApp()
     self.user = profile_utils.seedNDBProfile(self.gsoc.key())
     self.sponsor = program_utils.seedSponsor(sponsor_id='google')
     self.site = program_utils.seedSite(
         latest_gsoc=self.sponsor.key().name() + '/' + self.program,
         active_program=self.gsoc)
Пример #19
0
  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    sponsor = program_utils.seedSponsor()
    program = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
    self.organization = org_utils.seedSOCOrganization(program.key())

    user = profile_utils.seedNDBUser()
    profile_utils.loginNDB(user)
    self.profile = profile_utils.seedNDBProfile(program.key(), user=user)

    kwargs = {
        'sponsor': sponsor.key().name(),
        'program': program.program_id,
        'organization': self.organization.org_id,
        }
    self.data = request_data.RequestData(None, None, kwargs)
Пример #20
0
  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    # seed two programs for the same sponsor
    sponsor = program_utils.seedSponsor()
    self.program_one = program_utils.seedProgram(sponsor_key=sponsor.key())
    program_two = program_utils.seedProgram(sponsor_key=sponsor.key())

    org_one = org_utils.seedOrganization(self.program_one.key())
    org_two = org_utils.seedOrganization(program_two.key())

    self.mentor_keys = set()
    # seed a few mentors for both programs
    for _ in range(_NUMBER_OF_MENTORS):
      self.mentor_keys.add(profile_utils.seedNDBProfile(
          self.program_one.key(), mentor_for=[org_one.key]).key)
      profile_utils.seedNDBProfile(program_two.key(), mentor_for=[org_two.key])
Пример #21
0
    def setUp(self):
        """See unittest.TestCase.setUp for specification."""
        sponsor = program_utils.seedSponsor()
        program = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())
        self.organization = org_utils.seedSOCOrganization(program.key())

        user = profile_utils.seedNDBUser()
        profile_utils.loginNDB(user)
        self.profile = profile_utils.seedNDBProfile(program.key(), user=user)

        kwargs = {
            'sponsor': sponsor.key().name(),
            'program': program.program_id,
            'organization': self.organization.org_id,
        }
        self.data = request_data.RequestData(None, None, kwargs)
Пример #22
0
  def testProjectExists(self):
    """Tests that project is returned correctly if exists."""
    sponsor = program_utils.seedSponsor()
    program = program_utils.seedProgram(sponsor_key=sponsor.key())

    profile = profile_utils.seedSOCStudent(program)
    project = project_utils.seedProject(profile, program.key())

    kwargs = {
        'sponsor': sponsor.link_id,
        'program': program.program_id,
        'user': profile.profile_id,
        'id': str(project.key().id())
        }
    data = request_data.RequestData(None, None, kwargs)
    url_project = data.url_project
    self.assertEqual(project.key(), url_project.key())
Пример #23
0
    def testProjectExists(self):
        """Tests that project is returned correctly if exists."""
        sponsor = program_utils.seedSponsor()
        program = program_utils.seedProgram(sponsor_key=sponsor.key())

        profile = profile_utils.seedSOCStudent(program)
        project = project_utils.seedProject(profile, program.key())

        kwargs = {
            'sponsor': sponsor.link_id,
            'program': program.program_id,
            'user': profile.profile_id,
            'id': str(project.key().id())
        }
        data = request_data.RequestData(None, None, kwargs)
        url_project = data.url_project
        self.assertEqual(project.key(), url_project.key())
Пример #24
0
  def setUp(self):
    """Setup required to test the functions.

    Two different program entities are created with their own set of students
    assigned to them. Some of the students in each program have duplicate
    proposals and some not.
    """
    sponsor = program_utils.seedSponsor()

    self.program1 = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())

    #Create GSoCStudents in program1
    self.gsoc_students = []
    for _ in xrange(5):
      student = profile_utils.seedNDBStudent(self.program1)
      self.gsoc_students.append(student)

    #Create a GSoCProposalDuplicate entity for all the students
    #in self.gsoc_students for program1.
    self.proposal_duplicates = []
    for student in self.gsoc_students:
      proposal_duplicate = self.createGSoCProposalDuplicate(
          student, self.program1)
      self.proposal_duplicates.append(proposal_duplicate)

    #Create other program entity.
    self.program2 = program_utils.seedGSoCProgram(sponsor_key=sponsor.key())

    #Create students in program2.
    self.other_gsoc_students = []
    for _ in xrange(5):
      student = profile_utils.seedNDBStudent(self.program2)
      self.other_gsoc_students.append(student)

    #Create a GSoCProposalDuplicate entity for all the students
    #in self.other_gsoc_students for program2.
    self.other_proposal_duplicates = []
    for student in self.other_gsoc_students:
      proposal_duplicate = self.createGSoCProposalDuplicate(student,
                                                            self.program2)
      self.other_proposal_duplicates.append(proposal_duplicate)

    #Create a GSocProposalDuplicateStatusEntity for other_program
    properties = {'program': self.program2}
    self.gpds = seeder_logic.seed(GSoCProposalDuplicatesStatus, properties)
Пример #25
0
    def testConnectionExists(self):
        """Tests that connection is returned correctly if exists."""
        sponsor = program_utils.seedSponsor()
        program = program_utils.seedProgram(sponsor_key=sponsor.key())
        org = org_utils.seedOrganization(program.key())

        profile = profile_utils.seedNDBProfile(program.key())
        connection = connection_utils.seed_new_connection(profile.key, org.key)

        kwargs = {
            'sponsor': sponsor.link_id,
            'program': program.program_id,
            'user': profile.profile_id,
            'id': str(connection.key.id())
        }
        data = request_data.RequestData(None, None, kwargs)
        url_connection = data.url_connection
        self.assertEqual(connection.key, url_connection.key)
Пример #26
0
    def setUp(self):
        sponsor = program_utils.seedSponsor()

        # seed a timeline and set student app period for now
        self.timeline = program_utils.seedTimeline(
            models=types.SOC_MODELS,
            timeline_id=TEST_PROGRAM_ID,
            sponsor_key=sponsor.key(),
            student_signup_start=timeline_utils.past(),
            student_signup_end=timeline_utils.future())

        self.program = program_utils.seedGSoCProgram(
            program_id=TEST_PROGRAM_ID,
            sponsor_key=sponsor.key(),
            timeline_key=self.timeline.key(),
            app_tasks_limit=3)

        self.student = profile_utils.seedNDBStudent(self.program)
Пример #27
0
  def testConnectionExists(self):
    """Tests that connection is returned correctly if exists."""
    sponsor = program_utils.seedSponsor()
    program = program_utils.seedProgram(sponsor_key=sponsor.key())
    org = org_utils.seedOrganization(program.key())

    profile = profile_utils.seedNDBProfile(program.key())
    connection = connection_utils.seed_new_connection(profile.key, org.key)

    kwargs = {
        'sponsor': sponsor.link_id,
        'program': program.program_id,
        'user': profile.profile_id,
        'id': str(connection.key.id())
        }
    data = request_data.RequestData(None, None, kwargs)
    url_connection = data.url_connection
    self.assertEqual(connection.key, url_connection.key)
Пример #28
0
  def testOrgExists(self):
    """Tests that organization is returned correctly if exists."""
    sponsor = program_utils.seedSponsor()
    program = seeder_logic.seed(program_model.Program)
    org_properties = {
        'key_name': '%s/%s/test_org' % (sponsor.link_id, program.program_id),
        'link_id': 'test_org',
        }
    org = seeder_logic.seed(org_model.Organization, org_properties)

    kwargs = {
        'sponsor': sponsor.link_id,
        'program': program.program_id,
        'organization': org.link_id
        }
    data = request_data.RequestData(None, None, kwargs)
    url_org = data.url_org
    self.assertEqual(org.key(), url_org.key())
Пример #29
0
    def testOrgExists(self):
        """Tests that organization is returned correctly if exists."""
        sponsor = program_utils.seedSponsor()
        program = seeder_logic.seed(program_model.Program)
        org_properties = {
            'key_name':
            '%s/%s/test_org' % (sponsor.link_id, program.program_id),
            'link_id': 'test_org',
        }
        org = seeder_logic.seed(org_model.Organization, org_properties)

        kwargs = {
            'sponsor': sponsor.link_id,
            'program': program.program_id,
            'organization': org.link_id
        }
        data = request_data.RequestData(None, None, kwargs)
        url_org = data.url_org
        self.assertEqual(org.key(), url_org.key())
Пример #30
0
  def setUp(self):
    sponsor = program_utils.seedSponsor()

    # seed a timeline and set student app period for now
    self.timeline = program_utils.seedTimeline(
        models=types.SOC_MODELS, timeline_id=TEST_PROGRAM_ID,
        sponsor_key=sponsor.key(), student_signup_start=timeline_utils.past(),
        student_signup_end=timeline_utils.future(delta=50),
        accepted_students_announced_deadline=timeline_utils.future(delta=75))

    self.program = program_utils.seedGSoCProgram(
        program_id=TEST_PROGRAM_ID, sponsor_key=sponsor.key(),
        timeline_key=self.timeline.key(), app_tasks_limit=3)

    # seed a new student info
    self.student = profile_utils.seedNDBStudent(self.program)

    # seed a new proposal
    self.proposal = proposal_utils.seedProposal(
        self.student.key, self.program.key(),
        status=proposal_model.STATUS_WITHDRAWN)
Пример #31
0
  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    sponsor = program_utils.seedSponsor()

    program_properties = {
        'sponsor': sponsor,
        'scope': sponsor,
        }
    program = seeder_logic.seed(
        program_model.Program, properties=program_properties)

    org_properties = {
        'program': program,
        'scope': program,
        }
    self.organization = seeder_logic.seed(
        org_model.Organization, properties=org_properties)

    kwargs = {
        'sponsor': sponsor.key().name(),
        'program': program.link_id,
        'organization': self.organization.link_id,
        }
    self.data = request_data.RequestData(None, None, kwargs)
Пример #32
0
    def setUp(self):
        """See unittest.TestCase.setUp for specification."""
        sponsor = program_utils.seedSponsor()

        program_properties = {
            'sponsor': sponsor,
            'scope': sponsor,
        }
        program = seeder_logic.seed(program_model.Program,
                                    properties=program_properties)

        org_properties = {
            'program': program,
            'scope': program,
        }
        self.organization = seeder_logic.seed(org_model.Organization,
                                              properties=org_properties)

        kwargs = {
            'sponsor': sponsor.key().name(),
            'program': program.link_id,
            'organization': self.organization.link_id,
        }
        self.data = request_data.RequestData(None, None, kwargs)
Пример #33
0
  def setUp(self):
    """See unittest.TestCase.setUp for specification."""
    sponsor = program_utils.seedSponsor()
    program = program_utils.seedProgram(sponsor_key=sponsor.key())
    self.survey = program_utils.seedApplicationSurvey(program.key())

    # seed some organizations with survey responses
    self.app_responses = set()
    for _ in range(TEST_ORGS_NUMBER):
      org = org_utils.seedOrganization(program.key())
      self.app_responses.add(
          org_utils.seedApplication(org.key, self.survey.key()).key)

    # seed some organizations without survey responses
    for _ in range(TEST_ORGS_NUMBER):
      org_utils.seedOrganization(program.key())

    other_program = program_utils.seedProgram(sponsor_key=sponsor.key())
    other_survey = program_utils.seedApplicationSurvey(other_program.key())

    # seed some organizations with survey responses for other survey
    for _ in range(TEST_ORGS_NUMBER):
      org = org_utils.seedOrganization(other_program.key())
      org_utils.seedApplication(org.key, other_survey.key())
Пример #34
0
    def setUp(self):
        """See unittest.TestCase.setUp for specification."""
        sponsor = program_utils.seedSponsor()
        program = program_utils.seedProgram(sponsor_key=sponsor.key())
        self.survey = program_utils.seedApplicationSurvey(program.key())

        # seed some organizations with survey responses
        self.app_responses = set()
        for _ in range(TEST_ORGS_NUMBER):
            org = org_utils.seedOrganization(program.key())
            self.app_responses.add(
                org_utils.seedApplication(org.key, self.survey.key()).key)

        # seed some organizations without survey responses
        for _ in range(TEST_ORGS_NUMBER):
            org_utils.seedOrganization(program.key())

        other_program = program_utils.seedProgram(sponsor_key=sponsor.key())
        other_survey = program_utils.seedApplicationSurvey(other_program.key())

        # seed some organizations with survey responses for other survey
        for _ in range(TEST_ORGS_NUMBER):
            org = org_utils.seedOrganization(other_program.key())
            org_utils.seedApplication(org.key, other_survey.key())
Пример #35
0
 def testSponsor(self):
   """Tests sponsor function."""
   sponsor = program_utils.seedSponsor()
   self.assertEqual(
       '/gci/program/create/%s' % sponsor.key().name(),
       self.linker.sponsor(sponsor, 'gci_program_create'))