initial swag at mods for 0.9.4

Author: klehman-rally

dists/pyral-0.9.2.tar.gz

@@ -0,0 +1,223 @@
+#!/usr/bin/python
+
+###################################################################################################
+#
+#  pyral.query_builder -  module to build Rally WSAPI compliant query clause
+#
+###################################################################################################
+
+__version__ = (0, 9, 4)
+
+import re
+import types
+import urllib
+
+###################################################################################################
+
+JSON_FORMAT = ".js"
+
+class RallyUrlBuilder(object):
+    """
+        An instance of this class is used to collect information needed to construct a
+        valid URL that can be issued in a REST Request to Rally.
+        The sequence of use is to obtain a RallyUrlBuilder for a named entity, 
+        provide qualifying criteria, augments, scoping criteria and any provision 
+        for a pretty response, and then call build to return the resulting resource URL.
+        An instance can be re-used (for the same entity) by simply re-calling the 
+        specification methods with differing values and then re-calling the build method.
+    """
+    parts = ['fetch', 'query', 'order', 
+             'workspace', 'project', 'projectScopeUp', 'projectScopeDown', 
+             'pagesize', 'start', 'pretty'
+            ]
+
+    def __init__(self, entity):
+        self.entity = entity
+
+    def qualify(self, fetch, query, order, pagesize, startIndex):
+        self.fetch = fetch
+        self.query = query
+        self.order = order
+        self.pagesize   = pagesize
+        self.startIndex = startIndex
+        self.workspace  = None
+        self.project    = None
+        self.scopeUp    = None
+        self.scopeDown  = None
+        self.pretty     = False
+            
+
+    def build(self, pretty=None):
+        if pretty:
+            self.pretty = True
+        
+        resource = "%s%s?" % (self.entity, JSON_FORMAT)
+
+        qualifiers = ['fetch=%s' % self.fetch]
+        if self.query:
+            #encodedQuery = self._prepQuery(self.query)
+            #qualifiers.append('%s=%s' % ('query', encodedQuery if encodedQuery else ""))
+            query_string = RallyQueryFormatter.parenGroups(self.query)
+##
+##            print "query_string: |query=(%s)|" % query_string
+##
+            qualifiers.append("query=(%s)" % query_string)
+        if self.order:
+            qualifiers.append("order=%s" % urllib.quote(self.order))
+        if self.workspace:
+            qualifiers.append(self.workspace)
+        if self.project:
+            qualifiers.append(self.project)
+        if self.scopeUp:
+            qualifiers.append(self.scopeUp)
+        if self.scopeDown:
+            qualifiers.append(self.scopeDown)
+
+        qualifiers.append('pagesize=%s' % self.pagesize)
+        qualifiers.append('start=%s'    % self.startIndex)
+
+        if self.pretty:
+            qualifiers.append('pretty=true')
+
+        resource += "&".join(qualifiers)
+##
+##        print "RallyUrlBuilder.build: resource= %s" % resource
+##
+        return resource
+
+    def augmentWorkspace(self, augments, workspace_ref):
+        wksp_augment = [aug for aug in augments if aug.startswith('workspace=')]
+        self.workspace = "workspace=%s" % workspace_ref
+        if wksp_augment:
+            self.workspace = wksp_augment[0]
+
+    def augmentProject(self, augments, project_ref):
+        proj_augment = [aug for aug in augments if aug.startswith('project=')]
+        self.project = "project=%s" % project_ref
+        if proj_augment:
+            self.project = proj_augment[0]
+
+    def augmentScoping(self, augments):
+        scopeUp   = [aug for aug in augments if aug.startswith('projectScopeUp=')]
+        if scopeUp:
+            self.scopeUp = scopeUp[0]
+        scopeDown = [aug for aug in augments if aug.startswith('projectScopeDown=')]
+        if scopeDown:
+            self.scopeDown = scopeDown[0]
+
+    def beautifyResponse(self):
+        self.pretty = True
+
+##################################################################################################
+
+class RallyQueryFormatter(object):
+    CONJUNCTIONS = ['and', 'AND', 'or', 'OR']
+    CONJUNCTION_PATT = re.compile('\s+(AND|OR)\s+', re.I | re.M)
+
+    @staticmethod
+    def parenGroups(criteria):
+        """
+            Keep in mind that Rally WSAPI only supports a binary expression of (x) op (y)
+            as in "(foo) and (bar)"
+            or     (foo) and ((bar) and (egg))  
+            Note that Rally doesn't handle (x and y and z) directly.
+            Look at the criteria to see if there are any parens other than begin and end 
+            if the only parens are at begin and end, strip them and subject the criteria to our
+            clause grouper and binary expression confabulator. 
+            Otherwise, we'll naively assume the caller knows what they are doing, ie., they are 
+            aware of the binary expression requirement.
+        """
+        def _encode(condition):
+            """
+                if cond has pattern of 'thing relation value', then urllib.quote it and return it
+                if cond has pattern of '(thing relation value)', then urllib.quote content inside parens
+                  then pass that result enclosed in parens back to the caller
+            """
+            first_last = "%s%s" % (condition[0], condition[-1])
+            if first_last == "()":
+                url_encoded = urllib.quote(condition)
+            else:
+                url_encoded = '(%s)' % urllib.quote(condition)
+
+            # replace the %xx encodings for '=', '(', ')', '!', and double quote characters
+            readable_encoded =      url_encoded.replace("%3D", '=')
+            readable_encoded = readable_encoded.replace("%22", '"')
+            readable_encoded = readable_encoded.replace("%28", '(')
+            readable_encoded = readable_encoded.replace("%29", ')')
+            readable_encoded = readable_encoded.replace("%21", '!')
+            return readable_encoded
+##
+##        print "RQF.parenGroups criteria parm: |%s|" % repr(criteria)
+##
+        
+        if type(criteria) in [types.ListType, types.TupleType]:
+            # by fiat (and until requested by a paying customer), we assume the criteria expressions are AND'ed
+            #conditions = [_encode(expression) for expression in criteria] 
+            conditions = [expression for expression in criteria] 
+            criteria = " AND ".join(conditions)
+##
+##            print "RallyQueryFormatter: criteria is sequence type resulting in |%s|" % criteria
+##
+
+        if type(criteria) == types.DictType:  
+            expressions = []
+            for field, value in criteria.items():
+                # have to enclose string value in double quotes, otherwise turn whatever the value is into a string
+                tval = '"%s"' % value if type(value) == types.StringType else '%s' % value
+                expression = ('%s = %s' % (field, tval)).replace(' ', '%20')
+                if len(criteria) == 1:
+                    return expression
+                expressions.append(expression)
+            criteria = " AND ".join(expressions)
+
+        # if the caller has a simple query in the form "(something = a_value)"
+        # then return the query as is (after stripping off the surrounding parens)
+        if     criteria.count('(')  == 1    and criteria.count(')')  == 1    and \
+               criteria.strip()[0]  == '('  and criteria.strip()[-1] == ')':
+            return criteria.strip()[1:-1].replace(' ', '%20')
+       
+        # if caller has more than one opening paren, summarily return the query 
+        # essentially untouched (except for encoding space chars).  
+        # The assumption is that the caller has correctly done the parenthisized grouping 
+        # to end up in a binary form
+        if criteria.count('(') > 1:
+            return criteria.strip().replace(' ', '%20')
+
+        parts = RallyQueryFormatter.CONJUNCTION_PATT.split(criteria.strip())
+##
+##        print "RQF parts: %s" % repr(parts)
+##
+        
+        # if no CONJUNCTION is in parts, use the condition as is (simple case)
+        conjunctions = [p for p in parts if p in RallyQueryFormatter.CONJUNCTIONS]
+        if not conjunctions:
+            expression = criteria.strip().replace(' ', '%20')
+            #expression = urllib.quote(criteria.strip()).replace('%28', '(').replace('%29', ')')
+##
+##            print "RQF.no_conjunctions: |%s|" % expression
+##
+            return expression
+
+        binary_expression = parts.pop()
+        while parts:
+            item = parts.pop()
+            if item in RallyQueryFormatter.CONJUNCTIONS:
+                conj = item
+                binary_expression = "%s (%s)" % (conj, binary_expression)
+                #binary_expression = "%s%%20(%s)" % (conj, binary_expression)
+            else:
+                cond = item
+                binary_expression = "(%s) %s" % (cond, binary_expression)
+                #binary_expression = "%s%%20(%s)" % (conj, binary_expression)
+
+        #final_expression = urllib.quote(binary_expression).replace('%28', '(').replace('%29', ')')
+        final_expression = binary_expression.replace('%28', '(')
+        final_expression =  final_expression.replace('%29', ')')
+##
+##        print "RQF.final_expression: |%s|" % final_expression
+##        print "=============================================="
+##
+        final_expression = final_expression.replace(' ', '%20')
+        return final_expression
+
+##################################################################################################

dists/pyral-0.9.2.zip

@@ -0,0 +1,157 @@
+#!/op/local/bin/python2.6
+
+import sys, os
+import types
+import py
+
+import pyral
+from pyral import Rally
+
+RallyRESTAPIError = pyral.context.RallyRESTAPIError
+
+##################################################################################################
+
+TRIAL = "trial.rallydev.com"
+
+TRIAL_USER = "[email protected]"
+TRIAL_PSWD = "************"
+
+EXAMPLE_ATTACHMENT_CONTENT = "The quck brown fox eluded the lumbering sloth\n"
+
+##################################################################################################
+
+def conjureUpAttachmentFile(filename, content=None, mimetype="text/plain"):
+    """
+    """
+    file_content = content or EXAMPLE_ATTACHMENT_CONTENT
+    with open(filename, 'w') as af:
+        af.write(file_content)
+    return True
+
+
+def retrieveAttachment(rally, artifact, attachmentFileName):
+    """
+        
+    """
+    pass
+
+def test_add_attachment():
+    """
+    """
+    rally = Rally(server=TRIAL, user=TRIAL_USER, password=TRIAL_PSWD)
+    # find a Project with some US artifacts
+    # pick one with no attachments
+    # create an attachment file (or choose a smallish file with a commonly used suffix)
+    # create the attachment in Rally and link it to the US artifact
+
+    wksp = rally.getWorkspace()
+    assert wksp.Name == "Yeti Manual Test Workspace"
+
+    response = rally.get('Project', fetch=False, limit=10)
+    assert response != None
+    assert response.status_code == 200
+
+    proj = rally.getProject()  # proj.Name == My Project
+    assert proj.Name == "My Project"
+
+    #response = rally.get("UserStory", fetch="FormattedID,Name,Attachments")
+    #for story in response:
+    #    print "%s %-48.48s %d" % (story.FormattedID, story.Name, len(story.Attachments))
+
+    candidate_story = "US96"
+    response = rally.get("UserStory", fetch="FormattedID,Name,Attachments", 
+                                   query='FormattedID = "%s"' % candidate_story)
+    print response.resultCount
+    story = response.next()
+##
+    return True
+##
+    assert len(story.Attachments) == 0
+
+    attachment_name = "Addendum.txt"
+    att_ok = conjureUpAttachmentFile(attachment_name)
+    assert att_ok == True
+
+    att = rally.addAttachment(story, attachment_name)
+    assert att.Name == attachment_name
+
+
+def test_get_attachment():
+    """
+    """
+    rally = Rally(server=TRIAL, user=TRIAL_USER, password=TRIAL_PSWD)
+    candidate_story = "US80"
+    target = 'FormattedID = "%s"' % candidate_story
+    response = rally.get("UserStory", fetch=True, query=target, project=None)
+    assert response.resultCount == 1
+    story = response.next()
+##
+    assert True == True
+    return True
+##
+    assert len(story.Attachments) == 1
+    attachment = story.Attachments[0]
+    expected_attachment_name = "Addendum.txt"
+    assert attachment.Name   == expected_attachment_name
+
+    attachment = rally.getAttachment(candidate_story, expected_attachment_name)
+    assert attachment.Name    == expected_attachment_name
+    assert attachment.Content == EXAMPLE_ATTACHMENT_CONTENT
+
+
+def x_test_detach_attachment():
+    """
+    """
+    rally = Rally(server=TRIAL, user=TRIAL_USER, password=TRIAL_PSWD)
+    candidate_story = "S78"
+    target = 'FormattedID = "%s"' % candidate_story
+
+    response = rally.get("UserStory", fetch=True, query=target, project=None)
+    assert response.resultCount == 1
+    story = response.next()
+    assert len(story.Attachments) == 1
+    attachment = story.Attachments[0]
+    expected_attachment_name = "Addendum.txt"
+    assert attachment.Name == expected_attachment_name
+
+    result = rally.deleteAttachment(story, expected_attachment_name)
+    assert result != False
+    assert len(result.Attachments) == (len(story.Attachments) - 1)
+    
+
+def x_test_replace_attachment():
+    """
+    """
+
+
+def x_test_add_attachments():
+    """
+    """
+
+
+def x_test_get_attachments():
+    """
+    """
+
+
+def x_test_detach_attachments():
+    """
+    """
+
+
+def x_test_replace_attachments():
+    """
+    """
+
+    #expectedErrMsg = "hostname '%s' non-existent or unreachable" % bogus_server
+    #with py.test.raises(RallyRESTAPIError) as excinfo:
+    #    rally = Rally(server=bogus_server,
+    #                        user=TRIAL_USER, 
+    #                        password=TRIAL_PSWD)
+    #actualErrVerbiage = excinfo.value.args[0]  # becuz Python2.6 deprecates message :-(
+    #assert excinfo.value.__class__.__name__ == 'RallyRESTAPIError'
+    #assert actualErrVerbiage == expectedErrMsg
+
+##########################################################################################
+
+