def test_compare_diff_page(self):
self.url = "http://www.google.com/"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
self.url2 = "http://www.bluemodus.com/"
self.driver.get(self.url2)
state2 = state_builder.get_current_state(self.driver)
assert state != state2
def test_compare_similar_pages(self):
self.url = "http://www.google.com/"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
self.url2 = "http://www.google.co.uk/"
self.driver.get(self.url2)
state2 = state_builder.get_current_state(self.driver)
assert state != state2
def test_compare_same_page_fails_missing_element(self):
self.url = "http://www.google.com/"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
state.elements.remove(state.elements[0])
self.url2 = "http://www.google.com/"
self.driver.get(self.url2)
state2 = state_builder.get_current_state(self.driver)
state2.elements.remove(state.elements[6])
assert state != state2
def test_subtract_state(self):
self.url = "http://www.google.com/"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
self.url2 = "http://www.google.co.uk/"
self.driver.get(self.url2)
state2 = state_builder.get_current_state(self.driver)
uk_diff = state2 - state
uk_diff.verify_state(self.driver)
def test_init_state(self):
self.url = "http://www.google.com"
blank_state = state_builder.get_blank_state()
blank_state.save()
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
state.save()
element = ElementState(locators=[Locator(by=By.NAME, value="q")])
element2 = ElementState(locators=[Locator(by=By.NAME, value="btnG")])
element.save()
element2.save()
nav_command = [Command(command=Command.NAVIGATE, config_key="url")]
type_command = [
Command(command=Command.SENDKEYS,
element=element,
config_key="search"),
Command(command=Command.SENDKEYS,
element=element,
config_key="enter")
]
action = Action(name="Navigate",
steps=nav_command,
start_state=blank_state,
end_state=state)
action.save()
action2 = Action(name="Search",
steps=type_command,
start_state=state,
end_state=blank_state)
action2.save()
config = RunConfig(
params={
"url": "http://www.google.com/",
"search": "Something",
"enter": Keys.ENTER
})
action.execute(self.driver, config)
action2.execute(self.driver, config)
time.sleep(5)
new_state = state_builder.get_current_state(self.driver)
new_state.save()
action2.end_state = new_state
action2.save()
new_state.init_actions = [action, action2]
new_state.save()
state_id = new_state.id
print state_id
self.driver.get("http://www.msn.com/")
new_state.initialize_state(self.driver, config)
def test_compare_state(self):
self.driver.get("http://www.google.com/")
state1 = state_builder.get_blank_state()
state1.save()
state2 = state_builder.get_current_state(self.driver)
state2.save()
self.driver.get("https://www.google.com/#q=something")
state3 = state_builder.get_current_state(self.driver)
state3.save()
config = RunConfig(params={
"url": "http://www.google.com/",
"search": "Something"
})
search_fields = element_filter.filter_contains_text(
state2.elements, "Search")
search_field = search_fields[0]
commands1 = [Command(command=Command.NAVIGATE, config_key="url")]
commands2 = [
Command(command=Command.SENDKEYS,
element=search_field,
config_key="search")
]
nav_action = Action(name="Google Nav",
steps=commands1,
start_state=state1,
end_state=state2)
search_action = Action(name="Google Search",
steps=commands2,
start_state=state2,
end_state=state3)
nav_action.save()
search_action.save()
test = Test(name="Google Search Failure",
actions=[nav_action, search_action])
test.save()
suite = Suite(name="Failure Example", tests=[test])
suite.execute(self.driver, config)
suite.save(cascade=True)
print suite.id
assert suite.suite_results[-1].passed
search_field.locators = [Locator(by=By.CLASS_NAME, value="INVALID")]
search_field.save()
suite.execute(self.driver, config=config)
results = suite.suite_results[-1]
assert not results.passed
comparison = StateComparer(self.driver).compare_states(
results.failed_state, results.actual_state)
assert len(comparison[0].elements) == len(comparison[1].elements)
def test_divide_state(self):
self.url = "http://www.google.com"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
self.url2 = "http://www.google.co.uk"
self.driver.get(self.url2)
state2 = state_builder.get_current_state(self.driver)
shared_state = state2 / state
shared_state.verify_state(self.driver)
self.driver.get("http://www.google.com/")
shared_state.verify_state(self.driver)
def test_add_new_element(self):
self.url = "http://www.google.com"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
num_elements = len(state.elements)
state.remove_element(state.elements[1])
new_state = state_builder.get_current_state(self.driver)
diff_state = new_state - state
assert len(diff_state.elements) == 1
for element in diff_state.elements:
state.add_element(element)
state.verify_state(self.driver)
assert len(state.elements) == num_elements
def test_state_builder(self):
self.url = "http://www.google.com/"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
for i in range(0, 5):
self.driver.get(self.url)
state.verify_state(self.driver)
def get_logout_action(self):
command1 = Command(command=Command.SENDKEYS,
element=self.username,
config_key=ElementType.USERNAME)
command2 = Command(command=Command.SENDKEYS,
element=self.password,
config_key=ElementType.PASSWORD)
command3 = Command(command=Command.CLICK, element=self.submit)
action = Action(name="Login %s" % self.start_state.url,
steps=[command1, command2, command3],
start_state=self.start_state)
response = action.execute(self.driver, self.config)
if response.passed and not self.start_state.is_state_present(
self.driver):
print "assuming login was successful because the state is no longer present"
self.end_state = state_builder.get_current_state(self.driver)
self.end_state.save()
action.end_state = self.end_state
action.save()
return action
else:
raise Exception("Could not generate login action")
def crawl_state(self, state):
for element in state.elements:
try:
state.initialize_state(self.driver)
print "Loaded initial state %s" % state.id
webelement = WebElement(self.driver, element.locators)
if webelement.is_displayed():
webelement.click()
new_state = state_builder.get_current_state(self.driver)
if new_state == state:
print "looks like this is the same state"
else:
new_state.save()
print 'new state found at %s %s' % (self.driver.current_url,new_state.id)
click_action = action_builder.get_click_action(element, state, new_state)
new_state.init_actions = state.init_actions
new_state.init_actions.append(click_action)
new_state.save()
state.actions.append(click_action)
state.save()
else:
logging.error("Could not reproduce state %s element %s not present" % (state, element))
except Exception as e:
print "Couldn't crawl element %s %s" % (element.locators, str(e))
return state
def generate(self):
actions = []
self.driver.get(self.url)
start_state = state_builder.get_current_state(self.driver)
start_state.save()
action = action_builder.get_nav_action(self.url, start_state)
action.save()
actions.append(action)
self.click_login = self.get_click_login_action(start_state)
if self.click_login is not None:
new_state = self.click_login.end_state
else:
new_state = start_state
self.type_username = self.get_type_username_action(new_state)
new_state = self.type_username.end_state
self.submit_user = self.get_submit_action(new_state)
new_state = self.submit_user.end_state
self.password = self.get_type_password_action(new_state)
self.submit = self.get_submit_action(new_state)
if self.click_login is not None:
actions.append(self.click_login)
actions.append(self.click_login)
actions.append(self.submit_user)
actions.append(self.password)
actions.append(self.submit)
test = Test(name="Login Test %s" % self.url, actions=actions)
test.save()
return test
def generate_login_test(self, url, username, password):
self.driver.get(url)
start_state = state_builder.get_current_state(self.driver)
start_state.save()
action = action_builder.get_nav_action(url, start_state)
action.save()
action2 = action_builder.get_login_action(self.driver, start_state,
username, password)
action2.save()
end_state = state_builder.get_current_state(self.driver)
end_state.save()
action3 = action_builder.get_verify_state_action(end_state)
test = Test(name="Login Test %s" % url,
actions=[action, action2, action3])
test.save()
return test
def test_compare_same_element(self):
self.driver.get("http://www.google.com/")
state = state_builder.get_current_state(self.driver)
element1 = state.elements[0]
element2 = state.elements[0]
from app.element_comparer import ElementComparer
result = ElementComparer(self.driver).compare_elements(
element1, element2)
assert result == 0
def test_get_missing_elements(self):
self.url = "http://www.google.com"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
state.elements.append(
WebElement(self.driver,
[Locator(by=By.CSS_SELECTOR, value="INVALID")]))
missing_elements = state.get_missing_elements(self.driver)
assert len(missing_elements) == 1
def test_scanner(self):
self.driver.get("http://www.google.com")
state = state_builder.get_current_state(self.driver)
scanner = StateScanner(self.driver)
missing_elements = scanner.check_state(state)
#expect 1 missing since gmail link cant be found
assert len(missing_elements) == 1, "missing %s elements" % len(missing_elements)
def generate_navigate_test(self, url):
self.driver.get(url)
end_state = state_builder.get_current_state(self.driver)
end_state.save()
action = action_builder.get_nav_action(url, end_state)
action.save()
action2 = action_builder.get_verify_state_action(end_state)
action2.save()
test = Test(name="Navigate %s Test" % url, actions=[action, action2])
test.save()
return test
def test_remove_missing_elements(self):
self.url = "http://www.google.com"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
state.elements.append(
WebElement(self.driver,
[Locator(by=By.CSS_SELECTOR, value="INVALID")]))
missing_elements = state.get_missing_elements(self.driver)
for element in missing_elements:
print "removing %s" % element
state.remove_element(element)
assert element not in state.elements
def test_builder_reuses_elements(self):
self.url = "http://www.google.com/"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
new_state = state_builder.get_new_state(self.driver, state)
for newelement in new_state.elements:
found = False
for stateelement in state.elements:
if newelement.id == stateelement.id:
found = True
if not found:
assert found, "Element ID not found, element was not reused %s" % newelement.locators
def crawl_url(self, url):
self.driver.get(url)
initial_state = state_builder.get_current_state(self.driver)
initial_state.save()
blank_state = state_builder.get_blank_state()
blank_state.save()
nav_action = action_builder.get_nav_action(url, initial_state)
nav_action.save()
initial_state.init_actions = [nav_action]
initial_state.save()
print "Saved initial state %s" % initial_state.id
return initial_state
def test_buidler_reuses_some_elemnts(self):
self.url = "http://www.google.com/"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
self.driver.get("https://images.google.com/?gws_rd=ssl")
new_state = state_builder.get_new_state(self.driver, state)
count = 0
for newelement in new_state.elements:
found = False
for stateelement in state.elements:
if newelement.id == stateelement.id:
count += 1
assert count >= 10, count
def get_state(self):
url = self.driver.current_url
page = Page.objects(url=url).first()
if page is None:
self.driver.get(url)
default_state = state_builder.get_current_state(self.driver)
default_state.name = self.page
default_state.save()
page = Page(url=url,
default_state=default_state,
states=[default_state])
page.name = self.page
page.save()
for state in page.states:
if state.name == self.page:
print "Found state %s" % state.name
return state
print "State not found, creating new state"
new_state = state_builder.get_current_state(self.driver)
new_state.save()
new_state.name = self.page
page.states.append(new_state)
page.save()
return new_state
def crawl_state(self, state):
for element in state.elements[:20]:
try:
state.initialize_state(self.driver)
print "Loaded initial state %s" % state.id
webelement = WebElement(self.driver, element.locators)
if webelement.is_displayed():
print "Clicking %s" % element
webelement.highlight(length=2, color="red")
webelement.click()
domain = url_parser.get_domain_from_url(
self.driver.current_url)
if domain not in state.url:
print "State is different domain"
break
if state.is_state_present(self.driver):
print "looks like this is the same state"
else:
new_state = state_builder.get_current_state(
self.driver)
new_state.save()
print 'new state found at %s %s' % (
self.driver.current_url, new_state.id)
click_action = action_builder.get_click_action(
element, state, new_state)
new_state.init_actions = state.init_actions
new_state.init_actions.append(click_action)
new_state.save()
state.actions.append(click_action)
state.save()
self.put(new_state)
else:
logging.error(
"Could not reproduce state %s element %s not present" %
(state, element))
except Exception as e:
print "Couldn't crawl element %s %s" % (element.locators,
str(e))
return state
def compare_to_live_state(self, state):
new_state = state_builder.get_current_state(self.driver)
state = self.compare_states(state, new_state)
return (len(state[0].elements),len(state[1].elements))
def test_sort_elements(self):
self.url = "http://www.percolate.com/platform"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
def test_verify_state(self):
self.url = "http://www.google.com"
self.driver.get(self.url)
state = state_builder.get_current_state(self.driver)
self.driver.get(self.url)
state.verify_state(self.driver)
