#!/usr/bin/env python

import sys, os

import types

import urllib

import py

try:

from urllib import unquote

except:

from urllib.parse import unquote

import pyral

from pyral import Rally

InvalidRallyTypeNameError = pyral.entity.InvalidRallyTypeNameError

from pyral.query_builder import RallyUrlBuilder, RallyQueryFormatter

##################################################################################################

from rally_targets import AGICEN, AGICEN_USER, AGICEN_PSWD

from rally_targets import DEFAULT_WORKSPACE, DEFAULT_PROJECT, NON_DEFAULT_PROJECT

from rally_targets import BOONDOCKS_WORKSPACE, BOONDOCKS_PROJECT

from rally_targets import PROJECT_SCOPING_TREE

##################################################################################################

def test_basic_query():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query (no qualifying criteria) for a known valid

Rally entity.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

response = rally.get('Project', fetch=False, limit=10)

assert response.status_code == 200

assert response.errors == []

assert response.warnings == []

assert response.resultCount > 0

def test_simple_named_fields_query():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query (no qualifying criteria) for a known valid

Rally entity. The fetch specifies a small number of known valid

attributes on the Rally entity.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

response = rally.get('Project', fetch="Owner,State", limit=10)

assert response.status_code == 200

assert len(response.errors) == 0

assert len(response._page) > 0

def test_all_fields_query():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query (no qualifying criteria) for a known valid

Rally entity. The fetch value is True so each entity returned in

the response (data) will have its _hydrated attribute value set to True.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

response = rally.get('Project', fetch=True, limit=10)

assert response.status_code == 200

assert len(response.errors) == 0

assert response.resultCount > 1

for project in response:

assert project.oid > 0

assert len(project.Name) > 0

assert project._hydrated == True

def test_bogus_query():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query specifying a entity for which there is no valid Rally entity.

The status_code in the response must not indicate a valid request/response

and the errors attribute must have some descriptive info about the error.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

bogus_entity = "Payjammas"

expectedErrMsg = "not a valid Rally entity: %s" % bogus_entity

with py.test.raises(InvalidRallyTypeNameError) as excinfo:

response = rally.get('Payjammas', fetch=False, limit=10)

actualErrVerbiage = excinfo.value.args[0] # becuz Python2.6 deprecates message :-(

assert excinfo.value.__class__.__name__ == 'InvalidRallyTypeNameError'

assert actualErrVerbiage == bogus_entity

def test_good_and_bad_fields_query():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query (no qualifying criteria) for a known valid

Rally entity. The fetch spec should contain both valid attributes and

invalid attributes. The request should succeed but the instances returned

in the response data should not have the invalid attribute names, but

should have attribute names/values for the correctly specified entity attributes.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

response = rally.get('Project', fetch="Owner,State,Fabulote,GammaRays", limit=10)

project = response.next()

name = None

state = None

fabulote = None

gammaRays = None

try:

name = project.Owner.Name

except:

name = 'undefined'

try:

state = project.State

except:

state = 'undefined'

try:

fabulote = project.Fabulote

except:

fabulote = 'undefined'

try:

gammaRays = project.GammaRays

except:

gammaRays = 'undefined'

assert name != None

assert state != None

assert fabulote == 'undefined'

assert gammaRays == 'undefined'

def test_multiple_entities_query():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query (no qualifying criteria) for a comma

separated list of known valid Rally entity names.

As of Rally WSAPI 1.x, this is an invalid request;

only a single Rally entity can be specified.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

multiple_entities = "Project,Workspace"

with py.test.raises(InvalidRallyTypeNameError) as excinfo:

response = rally.get(multiple_entities, fetch=False, limit=10)

actualErrVerbiage = excinfo.value.args[0]

assert excinfo.value.__class__.__name__ == 'InvalidRallyTypeNameError'

assert actualErrVerbiage == multiple_entities

def test_multiple_page_response_query():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query (no qualifying criteria) against a Rally entity

(Defect) known to have more than 5 items. Set the pagesize to 5 to

force pyral to retrieve multiple pages to satisfy the query.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

response = rally.get('Defect', fetch=False, pagesize=5, limit=15)

count = 0

for ix, bugger in enumerate(response):

count += 1

assert response.resultCount > 5

assert count <= response.resultCount

assert count == 15

def test_defects_revision_history():

"""

Using a known valid Rally server and known valid access credentials,

issue a simple query (no qualifying criteria) against a Rally entity

(Defect) known to have an attribute (RevisionHistory) that has an

attribute (Revisions) that is a Rally collections reference.

This test demonstrates the lazy-evaluation of non first-level attributes.

Ultimately, the attributes deeper than the first level must be obtained

and have their attributes filled out completely (_hydrated == True).

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

response = rally.get('Defect', fetch=True, limit=10)

defect1 = response.next()

defect2 = response.next()

assert defect1.oid != defect2.oid

d1_revs = defect1.RevisionHistory.Revisions

d2_revs = defect2.RevisionHistory.Revisions

assert type(d1_revs) == list

assert type(d2_revs) == list

d1_rev1 = d1_revs.pop() # now the revs are in stack order, newest first, original the last

d2_rev1 = d2_revs.pop() # ditto

assert d1_rev1.RevisionNumber == 0

assert d2_rev1.RevisionNumber == 0

assert d1_rev1.Description != "" and len(d1_rev1.Description) > 0

assert d2_rev1.Description != "" and len(d2_rev1.Description) > 0

assert d1_rev1._hydrated == True

assert d2_rev1._hydrated == True

def test_single_condition_query_plain_expression():

"""

Using a known valid Rally server and known valid access credentials,

issue a query with a single qualifying criterion against a Rally entity

(Defect) known to exist for which the qualifying criterion should return

one or more Defects. The qualifying criterion is a string that is _not_

surrounded with paren chars.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

workspace = rally.getWorkspace()

project = rally.getProject()

qualifier = 'State = "Submitted"'

response = rally.get('Defect', fetch=True, query=qualifier, limit=10)

assert response.resultCount > 0

def test_single_condition_query_parenned():

"""

Using a known valid Rally server and known valid access credentials,

issue a query with a single qualifying criterion against a Rally entity

(Defect) known to exist for which the qualifying criterion should return

one or more Defects. The qualifying criterion is a string that _is_

surrounded with paren chars.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifier = "(State = Submitted)"

#qualifier = '(FormattedID = "US100")'

response = rally.get('Defect', fetch=True, query=qualifier, limit=10)

assert response.resultCount > 0

def test_two_condition_query_in_unparenned_string():

"""

Using a known valid Rally server and known valid access credentials,

issue a query with two qualifying conditions against a Rally entity

(Defect) known to exist for which the qualifying criterion should return

one or more Defects. The qualifying criterion is a list that contains

two condition strings, each condition string does _not_ have any

surrounding paren chars.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

double_qualifier = "State = Submitted AND FormattedID != US100"

response = rally.get('Defect', fetch=True, query=double_qualifier, limit=10)

assert response.resultCount > 0

def test_two_condition_query_parenned():

"""

Using a known valid Rally server and known valid access credentials,

issue a query with two qualifying conditions against a Rally entity

(Defect) known to exist for which the qualifying criterion should return

one or more Defects. The qualifying criterion is a string that _is_

surrounded with paren chars and each condition itself is surrounded by

parens..

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifiers = "((State = Submitted) AND (FormattedID != US100))"

response = rally.get('Defect', fetch=True, query=qualifiers, limit=10)

assert response.resultCount > 0

def test_four_ored_conditions_in_parrened_string():

"""

Take a user query with OR conditions in which the parenneg groups are

already supplied in AgileCentral conformant "binary" condition style

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD,

workspace=BOONDOCKS_WORKSPACE, project=BOONDOCKS_PROJECT)

qualifiers = '((((Name = "Brazen%20Milliwogs") OR (Name = "Jenkins")) OR (Name = "Refusnik")) OR (Name = "Salamandra"))'

response = rally.get('Project', fetch=True, query=qualifiers, limit=10)

assert response.resultCount > 0

projects = [project for project in response]

#print([project.Name for project in projects])

assert response.resultCount == 2 # Only Jenkins and Salamandra exist or or accessible to the accessing account

def test_single_condition_query_as_list():

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifier = ['State != Open']

response = rally.get('Defect', fetch=True, query=qualifier, limit=10)

assert response.resultCount > 0

def test_two_condition_query_in_list():

"""

Using a known valid Rally server and known valid access credentials,

issue a query with two qualifying conditions against a Rally entity

(Defect) known to exist for which the qualifying criterion should return

one or more Defects. The qualifying criterion is a list that contains

two condition strings, each condition string does _not_ have any

surrounding paren chars.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifiers = ["State = Submitted", "FormattedID != US100"]

response = rally.get('Defect', fetch=True, query=qualifiers, limit=10)

assert response.resultCount > 0

def test_three_condition_query_in_list():

"""

Using a known valid Rally server and known valid access credentials,

issue a query with three qualifying conditions against a Rally entity

(Defect) known to exist for which the qualifying criterion should return

one or more Defects. The qualifying criterion is a list that contains

three condition strings, each condition string does _not_ have any

surrounding paren chars.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

#qualifiers = ["State = Submitted", "FormattedID != DE100", "Owner.UserName != horsefeathers"]

qualifiers = ["State = Submitted", "FormattedID != DE100", "Severity != UltraMegaHurt"]

response = rally.get('Defect', fetch=True, query=qualifiers, limit=10)

assert response.resultCount > 0

def test_five_condition_query_in_list():

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifiers = ["State = Submitted",

"FormattedID < DE22",

"FormattedID != DE17",

'Priority = "High Attention"',

"Severity != Cosmetic"

]

response = rally.get('Defect', fetch=True, query=qualifiers, limit=10)

assert response.resultCount > 0

def test_single_condition_query_as_dict():

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifier = {'State' : 'Submitted'}

response = rally.get('Defect', fetch=True, query=qualifier, limit=10)

assert response.resultCount > 0

def test_two_conditions_query_as_dict():

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifiers = {'State' : 'Submitted',

'Ready' : 'False'

}

response = rally.get('Defect', fetch=True, query=qualifiers, limit=10)

assert response.resultCount > 0

def test_three_conditions_query_as_dict():

"""

"""

# TODO: note that an attribute value containing a '/' char will fail

# have yet to determine how to get this to work with Rally WSAPI ...

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifiers = {"State" : "Submitted",

"Priority" : "High Attention",

"Ready" : "False"

#'Severity : "Major Problem"',

#'Severity : "Crash/DataLoss"',

}

response = rally.get('Defect', fetch=True, query=qualifiers, limit=10)

assert response.resultCount > 0

def test_limit_query():

"""

Use a pagesize of 200 and a limit of 80 in the params in the URL

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifier = "State = Submitted"

response = rally.get('Defect', fetch=True, query=qualifier, pagesize=100, limit=30)

items = [item for item in response]

assert len(items) == 30

def test_start_value_query():

"""

Use a pagesize of 200 and a start index value of 10 in the params in the URL

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifier = "State = Submitted"

response = rally.get('Defect', fetch=True, query=qualifier, pagesize=200, start=10)

items = [item for item in response]

assert len(items) > 20

assert len(items) < 1000

def test_start_and_limit_query():

"""

Use a pagesize of 50 and a start index value of 10 and a limit of 40 in the params in the URL

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

qualifier = "State = Submitted"

response = rally.get('Defect', fetch=True, query=qualifier, pagesize=50, start=10,limit=40)

items = [item for item in response]

assert len(items) > 10

assert len(items) <= 40

def test_query_target_value_with_ampersand():

"""

Query for a Project.Name = 'R&D'

"""

criteria = ['Project.Name = R&D']

result = RallyQueryFormatter.parenGroups(criteria)

assert unquote(result) == 'Project.Name = R&D'.replace('&', '%26')

criteria = ['Project.Name = "R&D"']

result = RallyQueryFormatter.parenGroups(criteria)

assert unquote(result) == 'Project.Name = "R&D"'.replace('&', '%26')

criteria = ['Project.Name contains "R&D"']

result = RallyQueryFormatter.parenGroups(criteria)

assert unquote(result) == 'Project.Name contains "R&D"'.replace('&', '%26')

criteria = 'Railhead.Company.Name != "Atchison Topeka & Santa Fe & Cunard Lines"'

result = RallyQueryFormatter.parenGroups(criteria)

assert unquote(result) == criteria.replace('&', '%26')

def test_query_target_value_with_and():

"""

Query for a Project.Name = 'Operations and Support Group'

"""

criteria = 'Project.Name = "Operations and Support Group"'

result = RallyQueryFormatter.parenGroups(criteria)

assert result == 'Project.Name = "Operations and Support Group"'.replace(' ', '%20')

criteria = ['State != Open', 'Name !contains "Henry Hudson and Company"']

result = RallyQueryFormatter.parenGroups(criteria)

assert result.replace('%21%3D', '!=') == '(State != Open) AND (Name !contains "Henry Hudson and Company")'.replace(' ', '%20')

def test_query_with_special_chars_in_criteria():

"""

DE3228 in DEFAULT_WORKSPACE / DEFAULT_PROJECT has Name = Special chars:/!@#$%^&*()-=+[]{};:./<>?/

query for it by looking for it by the name value

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

rally.setWorkspace(DEFAULT_WORKSPACE)

rally.setProject(DEFAULT_PROJECT)

#rally.enableLogging('spec_char_query')

criteria = 'Name = "distinctive criteria of -32% degradation in rust protection"'

response = rally.get('Defect', fetch=True, query=criteria, limit=10)

assert response.__class__.__name__ == 'RallyRESTResponse'

assert response.status_code == 200

assert response.errors == []

assert response.warnings == []

assert response.resultCount == 1

criteria = 'Name = "Looking for the #blowback hashtag"'

response = rally.get('Defect', fetch=True, query=criteria, limit=10)

assert response.status_code == 200

assert response.errors == []

assert response.warnings == []

assert response.resultCount == 1

special_chars = "/!@#$%^*_-+=?{}[]:;,.<>"

# characters that break the RallyQueryFormatter and/or WSAPI: ( ) ~ & | backslash

for character in special_chars:

criteria = 'Name contains "%s"' % character

response = rally.get('Defect', fetch=True, query=criteria, limit=10)

assert response.__class__.__name__ == 'RallyRESTResponse'

assert response.status_code == 200

assert response.errors == []

assert response.warnings == []

assert response.resultCount >= 1

criteria = 'Name = "Special chars:/!@#$%^*-=+[]{};:,.<>? in the name field"'

response = rally.get('Defect', fetch=True, query=criteria, limit=10)

assert response.__class__.__name__ == 'RallyRESTResponse'

assert response.status_code == 200

assert response.errors == []

assert response.warnings == []

assert response.resultCount >= 1

def test_query_with_matched_parens_in_condition_value():

"""

The default workspace and project has a Release in it whose name contains a matched paren pair

make sure a query containing a condition looking for the Release by this name succeeds.

"""

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

#rally.enableLogging('query_condition_value_has_matched_internal_parens')

criteria = 'Name = "8.5 (Blah and Stuff)"'

response = rally.get('Release', fetch=True, query=criteria, limit=10)

assert response.__class__.__name__ == 'RallyRESTResponse'

assert response.status_code == 200

assert response.errors == []

assert response.warnings == []

assert response.resultCount >= 1

release = response.next()

assert release.Name == '8.5 (Blah and Stuff)'

def test_query_using_project_scoping_options():

"""

Target a Project that has subprojects with a population of Stories for a query,

using the projectScopeDown=False and then again with projectScopeDown=True.

The query specifying projectScopeDown=True should return more Stories than the initial query

"""

SCOPE_ROOT_PROJECT = 'Arctic Elevation'

rally = Rally(server=AGICEN, user=AGICEN_USER, password=AGICEN_PSWD)

projects = rally.getProjects(workspace=DEFAULT_WORKSPACE)

rally.setProject(SCOPE_ROOT_PROJECT)

response = rally.get('Story', fetch="FormattedID,Name,State,Project")

#assert response.resultCount == 11 # pre 1.2.4 behavior

assert response.resultCount == 4 # expected 1.2.4 behavior

response = rally.get('Story', fetch="FormattedID,Name,State", projectScopeDown=True)

assert response.resultCount == 11

response = rally.get('Story', fetch="FormattedID,Name,State", projectScopeDown=False)

assert response.resultCount == 4

ISOLATED_SUB_PROJECT = 'Aurora Borealis'

#print("\nISOLATED_SUB_PROJECT: %s" % ISOLATED_SUB_PROJECT)

response = rally.get('Story', fetch="FormattedID,Name,State,Project",

project=ISOLATED_SUB_PROJECT, projectScopeDown=False,

order="FormattedID,Project.Name")

assert response.resultCount == 2

response = rally.get('Story', fetch="FormattedID,Name,State",

project=ISOLATED_SUB_PROJECT, projectScopeDown=True)

assert response.resultCount == 2

response = rally.get('Story', fetch="FormattedID,Name,State",

project=ISOLATED_SUB_PROJECT, projectScopeUp=True)

assert response.resultCount == 6

BEEFIER_SUB_PROJECT = 'Sub Arctic Conditions'

#print("BEEFIER_SUB_PROJECT: %s" % BEEFIER_SUB_PROJECT)

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BEEFIER_SUB_PROJECT,

projectScopeDown=False)

assert response.resultCount == 3

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BEEFIER_SUB_PROJECT,

projectScopeUp=True,

projectScopeDown=False)

assert response.resultCount == 7

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BEEFIER_SUB_PROJECT,

projectScopeDown=True)

assert response.resultCount == 5

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BEEFIER_SUB_PROJECT,

projectScopeUp=False,

projectScopeDown=True)

assert response.resultCount == 5

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BEEFIER_SUB_PROJECT,

projectScopeUp=True,

projectScopeDown=True)

assert response.resultCount == 9

# BOTTOM_PROJECT is a sub-project under BEEFIER_SUB_PROJECT

BOTTOM_PROJECT = 'Bristol Bay Barons'

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BOTTOM_PROJECT)

assert response.resultCount == 2

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BOTTOM_PROJECT,

projectScopeDown=True)

assert response.resultCount == 2

response = rally.get('Story', fetch="FormattedID,Name,State",

project=BOTTOM_PROJECT,

projectScopeUp=True, projectScopeDown=True)

assert response.resultCount == 9

#test_basic_query()

#test_simple_named_fields_query()

#test_all_fields_query()

#test_bogus_query()

#test_good_and_bad_fields_query()

#test_multiple_entities_query()

#test_multiple_page_response_query()

#test_defects_revision_history()

#test_single_condition_query_plain_expression()

#test_single_condition_query_parenned()

#test_two_condition_query_in_unparenned_string()

#test_two_condition_query_parenned()

#test_single_condition_query_in_list()

#test_two_condition_query_in_list()

#test_three_condition_query_in_list()

#test_five_condition_query_in_list()

#test_single_condition_query_as_dict()

#test_two_conditions_query_as_dict()

#test_three_conditions_query_as_dict()

#test_limit_query()

#test_start_value_query()

#test_start_and_limit_query()

#test_query_target_value_with_ampersand()

#test_query_target_value_with_and()

#test_query_with_special_chars_in_criteria