Ejemplo n.º 1
0
    def test_should_return_not_found_for_valid_colleague_by_format_name_but_non_existent(self, mock_search):
        mock_search.return_value = MockQuery(None)

        request = testing.DummyRequest()
        request.matchdict['format_name'] = str(self.colleague.format_name)
        response = colleague_by_format_name(request)

        self.assertEqual(response.status_code, 404)
        self.assertEqual(json.loads(response.body), {'error': 'Colleague not found'})
Ejemplo n.º 2
0
    def test_should_return_colleague_by_format_name(self, mock_search, colleague_urls):
        
        def side_effect(*args, **kwargs):
            if args[0] == Colleague:
                return MockQuery(self.colleague)
            elif args[0].__dict__ == ColleagueKeyword.keyword_id.__dict__:
                return MockQuery(tuple([self.colleague_keyword.keyword_id]))
            elif args[0].__dict__ == Keyword.display_name.__dict__:
                return MockQuery(tuple([self.keyword.display_name]))
            elif len(args) == 2: # We can't group them into 'and'(&)-clauses because sqlalchemy overloads all the operator and then it would generate a query and not a boolean expression
                if args[0].__dict__ == ColleagueAssociation.associate_id.__dict__:
                    if args[1].__dict__ == ColleagueAssociation.association_type.__dict__:
                        return MockQuery((self.association_1_2.associate_id, self.association_1_2.association_type))
            elif len(args) == 3:
               if args[0].__dict__ == Colleague.first_name.__dict__:
                    if args[1].__dict__ == Colleague.last_name.__dict__:
                        if args[2].__dict__ == Colleague.format_name.__dict__:
                            return MockQuery((self.colleague_2.first_name, self.colleague_2.last_name, self.colleague_2.format_name))
            else:
                return MockQuery(None)
            
        mock_search.side_effect = side_effect
        colleague_urls.return_value = [self.url_1, self.url_2]

        request = testing.DummyRequest()
        request.matchdict['format_name'] = str(self.colleague.format_name)
        response = colleague_by_format_name(request)
        self.maxDiff = None
        self.assertEqual(response, {
            'orcid': self.colleague.orcid,
            'first_name': self.colleague.first_name,
            'last_name': self.colleague.last_name,
            'email': self.colleague.email,
            'position': self.colleague.job_title,
            'profession': self.colleague.profession,
            'organization': self.colleague.institution,
            'address': [self.colleague.address1],
            'city': self.colleague.city,
            'state': self.colleague.state,
            'country': self.colleague.country,
            'postal_code': self.colleague.postal_code,
            'work_phone': self.colleague.work_phone,
            'fax': self.colleague.fax,
            'webpages': {
                'lab_url': self.url_2.obj_url,
                'research_summary_url': self.url_1.obj_url
            },
            'associations': {'Lab member': [(self.colleague_2.first_name, self.colleague_2.last_name, self.colleague_2.format_name)]},
            'keywords': [self.keyword.display_name],
            'research_interests': self.colleague.research_interest,
            'last_update': str(self.colleague.date_last_modified)
        })