コード例 #1
0
 def test_ad_hoc_check_vote_query(self):
     """As of 11/4/2017, the tutorial contains an query done outside Relay, to check whether a
     vote already exists. (On the client side? Really? Ask forgiveness rather than permisson,
     and save a round trip.) The query is done using a private API function
     (relay.environment._network.fetch) that, sure enough, went away in recent versions of Relay.
     Test that that query works (for older Relay versions, and in the event the tutorial is fixed
     for newer versions.)
     """
     create_Link_orderBy_test_data() # creates more than one link
     user = create_test_user()
     user_gid = Node.to_global_id('User', user.pk)
     user2 = create_test_user(name='Another User', password='******', email='*****@*****.**')
     # create multiple votes
     for link in LinkModel.objects.all():
         last_vote = VoteModel.objects.create(link_id=link.pk, user_id=user.pk)
         VoteModel.objects.create(link_id=link.pk, user_id=user2.pk)
         last_link = link
     link_gid = Node.to_global_id('Link', last_link.pk)
     vote_gid = Node.to_global_id('Vote', last_vote.pk)
     # make sure the query only returns one vote
     query = '''
       query CheckVoteQuery($userId: ID!, $linkId: ID!) {
         viewer {
           allVotes(filter: {
             user: { id: $userId },
             link: { id: $linkId }
           }) {
             edges {
               node {
                 id
               }
             }
           }
         }
       }
     '''
     variables = {
         'userId': user_gid,
         'linkId': link_gid,
     }
     expected = {
         'viewer': {
             'allVotes': {
                 'edges': [
                     {
                         'node': {
                             'id': vote_gid,
                         }
                     }
                 ]
             }
         }
     }
     schema = graphene.Schema(query=Query)
     result = schema.execute(query, variable_values=variables)
     self.assertIsNone(result.errors, msg=format_graphql_errors(result.errors))
     self.assertEqual(result.data, expected, msg='\n'+repr(expected)+'\n'+repr(result.data))
コード例 #2
0
 def test_node_for_vote(self):
     link = LinkModel.objects.create(description='Test', url='http://a.com')
     user = create_test_user()
     vote = VoteModel.objects.create(link_id=link.pk, user_id=user.pk)
     vote_gid = Node.to_global_id('Vote', vote.pk)
     query = '''
       query {
         node(id: "%s") {
           id
           ...on Vote {
             link {
               url
             }
           }
         }
       }
     ''' % vote_gid
     expected = {
       'node': {
         'id': vote_gid,
         'link': {
           'url': 'http://a.com',
         }
       }
     }
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     self.assertIsNone(result.errors, msg=format_graphql_errors(result.errors))
     self.assertEqual(result.data, expected, msg='\n'+repr(expected)+'\n'+repr(result.data))
コード例 #3
0
def test_no_announcement_on_ideas(graphql_request, idea_with_en_fr):
    from graphene.relay import Node
    idea_id = idea_with_en_fr.id
    node_id = Node.to_global_id('Idea', idea_id)
    res = schema.execute(u"""
query Idea($id: ID!, $lang: String!){
    idea: node(id: $id) {
        ... on Idea {
            announcement {
                title(lang: $lang)
                body(lang: $lang)
            }
        }
    }
}""",
                         context_value=graphql_request,
                         variable_values={
                             "id": node_id,
                             "lang": "en"
                         })
    assert json.loads(json.dumps(res.data)) == {
        u'idea': {
            u'announcement': None
        }
    }
コード例 #4
0
 def test_node_for_user(self):
     user = create_test_user()
     user_gid = Node.to_global_id('User', user.pk)
     query = '''
       query {
         node(id: "%s") {
           id
           ...on User {
             name
           }
         }
       }
     ''' % user_gid
     expected = {
         'node': {
             'id': user_gid,
             'name': user.name,
         }
     }
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     self.assertIsNone(result.errors,
                       msg=format_graphql_errors(result.errors))
     self.assertEqual(result.data,
                      expected,
                      msg='\n' + repr(expected) + '\n' + repr(result.data))
コード例 #5
0
 def test_votes_count_on_link_test(self):
     """test count field on votes field on Link type"""
     # first link will have one vote, last link will have two
     create_Link_orderBy_test_data() # creates more than one link
     user = create_test_user()
     first_link_id = None
     for link in LinkModel.objects.all():
         vote = VoteModel.objects.create(link_id=link.pk, user_id=user.pk)
         # save these for below
         first_link_id = first_link_id or link.pk
         last_link_id = link.pk
     user2 = create_test_user(name='Another User', password='******', email='*****@*****.**')
     VoteModel.objects.create(link_id=last_link_id, user_id=user2.pk)
     # check vote counts
     first_link_gid = Node.to_global_id('Link', first_link_id)
     last_link_gid = Node.to_global_id('Link', last_link_id)
     query = '''
       query VotesOnLinkTest($linkId: ID!) {
         node(id: $linkId) {
           ... on Link {
             votes {
               count
             }
           }
         }
       }
     '''
     variables = {
         'linkId': first_link_gid,
     }
     expected = {
         'node': {
           'votes': {
             'count': 1,
           }
         }
     }
     schema = graphene.Schema(query=Query)
     result = schema.execute(query, variable_values=variables)
     self.assertIsNone(result.errors, msg=format_graphql_errors(result.errors))
     self.assertEqual(result.data, expected, msg='\n'+repr(expected)+'\n'+repr(result.data))
     variables['linkId'] = last_link_gid
     expected['node']['votes']['count'] = 2
     result = schema.execute(query, variable_values=variables)
     self.assertIsNone(result.errors, msg=format_graphql_errors(result.errors))
     self.assertEqual(result.data, expected, msg='\n'+repr(expected)+'\n'+repr(result.data))
コード例 #6
0
    def get_post_url(self, post):
        if current_phase_use_v1_interface(self.discussion.timeline_events):
            return self.get_discussion_url() + self.get_relative_post_url(post)
        else:
            route = None
            phase = post.get_created_phase()
            # The created post must be created within an associated phase
            assert phase
            if post.__class__.__name__ == 'SynthesisPost':
                synthesis_id = Node.to_global_id('Post', post.id)
                route = self.get_frontend_url('synthesis',
                                              slug=self.discussion.slug,
                                              synthesisId=synthesis_id)
                return urljoin(self.discussion.get_base_url(), route)
            first_idea = None
            ideas = [
                link.idea
                for link in post.indirect_idea_content_links_without_cache()
                if link.__class__.__name__ == 'IdeaRelatedPostLink'
            ]
            if ideas:
                first_idea = ideas[0]
            else:
                # orphan post, redirect to home
                return self.get_discussion_url()

            if first_idea is not None and first_idea.__class__.__name__ ==\
                    'Question':
                thematic = post.get_closest_thematic()
                route = self.get_frontend_url(
                    'post', **{
                        'phase': phase.identifier,
                        'themeId': thematic.graphene_id(),
                        'element': ''
                    })

            if not route:
                route = self.get_frontend_url(
                    'post', **{
                        'phase': phase.identifier,
                        'themeId': Node.to_global_id('Idea', first_idea.id),
                        'element': Node.to_global_id('Post', post.id)
                    })

            return urljoin(self.discussion.get_base_url(), route)
コード例 #7
0
 def setUp(self):
     create_Link_orderBy_test_data()
     self.link_gid = Node.to_global_id('Link', LinkModel.objects.latest('created_at').pk)
     self.user = create_test_user()
     self.user_gid = Node.to_global_id('User', self.user.pk)
     self.query = '''
       mutation CreateVoteMutation($input: CreateVoteInput!) {
         createVote(input: $input) {
           vote {
             link {
               id
               votes { count }
             }
           }
           clientMutationId
         }
       }
     '''
     self.schema = graphene.Schema(query=Query, mutation=Mutation)
コード例 #8
0
def test_url_to_synthesis_post_with_timeline(discussion, synthesis_post_1,
                                             timeline_phase2_interface_v2):
    from assembl.lib.frontend_urls import (FrontendUrls,
                                           get_current_phase_identifier,
                                           current_phase_use_v1_interface)
    from graphene.relay import Node
    frontend_urls = FrontendUrls(discussion)
    assert get_current_phase_identifier(discussion.timeline_events) ==\
        u'thread'
    assert current_phase_use_v1_interface(discussion.timeline_events) is False
    post_id = Node.to_global_id('Post', synthesis_post_1.id)
    assert '/syntheses/{id}'.format(id=post_id)\
        in frontend_urls.get_post_url(synthesis_post_1)
コード例 #9
0
 def test_create_vote_bad_link(self):
     """ensure invalid linkId causes failuer"""
     last_link_pk = LinkModel.objects.order_by('id').last().pk
     invalid_link_gid = Node.to_global_id('Link', last_link_pk + 1)
     result = self.schema.execute(
         self.query,
         variable_values=self.variables(invalid_link_gid, self.user_gid),
         context_value=self.context_with_token()
     )
     self.assertIsNotNone(result.errors,
                          msg='createVote should have failed: invalid linkId')
     self.assertIn('link not found', repr(result.errors))
     expected = { 'createVote': None }
     self.assertEqual(result.data, expected, msg='\n'+repr(expected)+'\n'+repr(result.data))
コード例 #10
0
 def test_create_vote_user_mismatch(self):
     """ensure logged user must match supplied userId"""
     user2 = create_test_user(name='Another User', password='******', email='*****@*****.**')
     user2_gid = Node.to_global_id('User', user2.pk)
     result = self.schema.execute(
         self.query,
         variable_values=self.variables(self.link_gid, user2_gid),
         context_value=self.context_with_token()
     )
     self.assertIsNotNone(result.errors,
                          msg='createVote should have failed: userId and logged user mismatch')
     self.assertIn('user id does not match logged-in user', repr(result.errors))
     expected = { 'createVote': None }
     self.assertEqual(result.data, expected, msg='\n'+repr(expected)+'\n'+repr(result.data))
コード例 #11
0
 def setUp(self):
     self.user = create_test_user()
     self.user_gid = Node.to_global_id('User', self.user.pk)
     self.query = '''
       mutation CreateLinkMutation($input: CreateLinkInput!) {
         createLink(input: $input) {
           link {
             url
             description
             postedBy {
               id
             }
           }
           clientMutationId
         }
       }
     '''
     self.schema = graphene.Schema(query=Query, mutation=Mutation)
コード例 #12
0
 def test_node_for_link(self):
     link = LinkModel.objects.create(description='Test', url='http://a.com')
     link_gid = Node.to_global_id('Link', link.pk)
     query = '''
       query {
         node(id: "%s") {
           id
           ...on Link {
             url
           }
         }
       }
     ''' % link_gid
     expected = {
       'node': {
         'id': link_gid,
         'url': 'http://a.com',
       }
     }
     schema = graphene.Schema(query=Query)
     result = schema.execute(query)
     self.assertIsNone(result.errors, msg=format_graphql_errors(result.errors))
     self.assertEqual(result.data, expected, msg='\n'+repr(expected)+'\n'+repr(result.data))
コード例 #13
0
 def resolve_token_category_id(self, args, context, info):
     return Node.to_global_id('TokenCategorySpecification',
                              self.token_category_id)
コード例 #14
0
ファイル: vote_session.py プロジェクト: magarrigue/assembl
 def resolve_vote_session_id(self, args, context, info):
     return Node.to_global_id('VoteSession', self.widget_id)
コード例 #15
0
ファイル: post.py プロジェクト: magarrigue/assembl
    def resolve_parent_id(self, args, context, info):
        if self.parent_id is None:
            return None

        return Node.to_global_id('Post', self.parent_id)
コード例 #16
0
 def resolve_voter_id(self, args, context, info):
     return Node.to_global_id('AgentProfile', self.voter_id)
コード例 #17
0
 def resolve_ancestors(self, args, context, info):
     return [
         Node.to_global_id('Idea', id)
         for id in self.get_all_ancestors(id_only=True)
     ]
コード例 #18
0
    def resolve_parent_id(self, args, context, info):
        parents = self.get_parents()
        if not parents:
            return None

        return Node.to_global_id('Idea', parents[0].id)
コード例 #19
0
 def resolve_vote_spec_id(self, args, context, info):
     return Node.to_global_id(self.vote_spec.__class__.__name__,
                              self.vote_spec_id)
コード例 #20
0
 def resolve_proposal_id(self, args, context, info):
     return Node.to_global_id('Idea', self.idea_id)
コード例 #21
0
 def graphene_id_for(cls, id):
     # who made the Post global Ids not follow the base class?
     from graphene.relay import Node
     return Node.to_global_id('Post', id)
コード例 #22
0
ファイル: idea.py プロジェクト: magarrigue/assembl
    def resolve_parent_id(self, args, context, info):
        if not self.source_links:
            return None

        return Node.to_global_id('Idea', self.source_links[0].source_id)