def MatrixS3D(Coords, n, Coefficients, el_type, Upwinded):
E = Element(el_type)
Se = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
weights = [1, 1]
x_0 = Coefficients[6]
r_c = Coefficients[4]
for i in range(len(x_ip)):
for j in range(len(x_ip)):
for k in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], x_ip[k])
N_T = N.transpose()
B, Jdet, G, J_inv = E.G_ext(x_ip[i], x_ip[j], x_ip[k], Coords)
B_T = B.transpose()
x_coord = np.array([Coords[:, 0]]) @ N_T
y_coord = np.array([Coords[:, 1]]) @ N_T
z_coord = np.array([Coords[:, 2]]) @ N_T
sigma = Coefficients[3](x_coord, y_coord, z_coord, r_c, x_0)
Se += -N_T * (
sigma) * N * Jdet * weights[i] * weights[j] * weights[k]
if Upwinded == True:
delta = CalcDelta3D(Coefficients,
[x_coord, y_coord, z_coord], n)
Se += -delta * np.dot(
B_T, n.transpose()
) * sigma * N * Jdet * weights[i] * weights[j] * weights[k]
return Se
def Dif_basic_F(S, Coords):
E = Element("Q4")
N = E.N()
G_map = E.G_map()
F = np.zeros((len(Coords), 1))
#print(F)
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
W_ip = [1, 1]
for i in range(len(x_ip)):
N_l = N(x_ip[i], x_ip[i]) #N local
N_T = np.transpose(N_l)
B, Jdet = G_map(x_ip[i], x_ip[i], Coords)
#print("N_T is ",N_T)
S_val = S(x_ip[i], x_ip[i])
#print(S_val)
F = F + N_T * S_val * Jdet * W_ip[i] * W_ip[i]
#print(F)
#reference file
file = open('../outputs/f_elemental.txt', 'w')
for i in range(4):
if i != 0:
file.write('\n')
file.write(str(F[i]))
file.write(" ")
file.close()
return F
def VectorF3D(Coords, n, Coefficients, sourceFunc, El_type, Upwinded):
E = Element(El_type)
weights = [1, 1]
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
f_ele = np.zeros((len(Coords), 1))
for i in range(len(x_ip)):
for j in range(len(x_ip)):
for k in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], x_ip[k])
N_T = N.transpose()
B, Jdet = E.G(x_ip[i], x_ip[j], x_ip[k], Coords)
B_T = B.transpose()
x_coord = np.array([Coords[:, 0]]) @ N_T
y_coord = np.array([Coords[:, 1]]) @ N_T
z_coord = np.array([Coords[:, 2]]) @ N_T
source = SourceTerm3D([x_coord, y_coord, z_coord],
Coefficients, sourceFunc)
f_ele += N_T * source * Jdet * weights[i] * weights[
j] * weights[k]
if Upwinded == True:
delta = CalcDelta3D(Coefficients,
[x_coord, y_coord, z_coord], n)
f_ele += delta * np.dot(B_T, n.transpose(
)) * source * Jdet * weights[i] * weights[j] * weights[k]
return f_ele
def Dif_basic_K(Coords, k=1): #let k be an optional arguement
num_nodes = 4 # number of nodes
E = Element("Q4")
# K = np.zeros((num_nodes,num_nodes))
# Now to step through K_mat and integrate each element
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
W_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
G_m = E.G_map()
B, Jdet = G_m(x_ip[i], x_ip[j], Coords)
B_T = np.transpose(B)
Ke = Ke + B_T.dot(B) * k * Jdet * W_ip[i] * W_ip[j]
#print(Ke)
#Ke = Ke + ((np.transpose(B)) * k * B * Jdet * W_ip[i] * W_ip[j])
#Ke = Ke + (np.dot(np.transpose(B_val), k*B_val) * abs(J_d_val)*w_ip[i]*w_ip[j])
#file = open('../outputs/K_elemental.txt', 'w')
#for i in range(4):
# if i != 0:
# file.write('\n')
# for j in range(4):
# file.write(str(K[i, j]))
# file.write(" ")
#file.close()
return Ke
def refresh(self):
Element.refresh(self)
if self.element:
self.element.refresh()
for dirty_rect in self.element.dirty_list:
self.dirty_list.append(dirty_rect)
self.element.dirty_list = []
return
def __init__(self, context):
super().__init__(context)
self.add_to_cart_button = Element(By.NAME, 'add_cart', context)
self.pdp_title = Element(
By.XPATH, '//h3[contains(@class, "pdp__title")]/parent::div',
context)
def update(self):
if self.element:
self.element.update()
self.rect = self.element.rect
for dirty_rect in self.element.dirty_list:
self.dirty_list.append(dirty_rect)
self.element.dirty_list = []
Element.update(self)
return
def __init__(self, _id, infos, vertex, matrix):
Element.__init__(self,
_id=_id,
infos=infos,
vertex=vertex,
matrix=matrix)
self.typeid = infos['typeid']
self.radius = ENTITY_RADIUS[self.typeid]
self.level = None
def __init__(self, element=None, grid_position=None, \
grid_camera=None, **kwargs):
Element.__init__(self, **kwargs)
self.element = element
if element:
self.rect = element.rect
self.grid_position = grid_position
self.grid_camera = grid_camera
return
def Dif_basic_K(el_type,
Coords,
k=1,
P_type='scalar'): #let k be an optional arguement
El = Element(el_type)
if el_type == 'Q4':
num_nodes = 4 # number of nodes
elif el_type == 'Q8':
num_nodes = 8
else:
print('Please enter a valid element type')
K = np.zeros((num_nodes, num_nodes))
G = El.G() # snag B-matrix for element
if (P_type == 'scalar'
): # calculates B function based on scalar or vector problem!
B = G
elif (P_type == 'vector'):
B = np.zeros((3, 8))
for i in range(2 * num_nodes):
B[0, 2 * i] = G[0, i]
B[1, 2 * i - 1] = G[1, i]
B[2, 2 * i] = G[0, i]
B[2, 2 * i - 1] = G[1, i]
else:
print('Please enter valid problem type')
#calculate jacobian determinant -- take another look at this!!!!!
J = lambda x, y: np.dot(G(x, y), Coords)
J_d = lambda x, y: np.linalg.det(J(x, y))
# K_mat = lambda x, y: np.dot(np.transpose(B(x,y)), k*B(x,y))*abs(Jd_m(x,y)) # Create K_matrix based on definition in scalar problem - heat
#K_mat = lambda x, y: np.dot(K_mat1(x,y), J(x,y)) ##if mapped element, compute jacobian and tack on
#print(K_mat(0,0)[0,0])
# Now to step through K_mat and integrate each element
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
w_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
B_val = G(x_ip[i], x_ip[j])
J_d_val = J_d(x_ip[i], x_ip[j])
#print(B_val)
#print(J_d_val)
Ke = Ke + (np.dot(np.transpose(B_val), k * B_val) * abs(J_d_val) *
w_ip[i] * w_ip[j])
print(Ke)
file = open('../outputs/K_elemental.txt', 'w')
for i in range(4):
if i != 0:
file.write('\n')
for j in range(4):
file.write(str(K[i, j]))
file.write(" ")
file.close()
return Ke
class CatalogPage(BasePage):
def __init__(self, context):
super().__init__(context)
self.product_title = Element(By.XPATH, '//a[contains(text(), "{}")]',
context)
def find_product_and_open_pdp(self, product_name):
self.product_title.set_parameters(product_name)
self.product_title.click()
def update(self):
def names_are_synchronized():
return self.image_name == self.old_image_name
def sizes_are_synchronize():
return self.old_rect is not None and self.rect.size == self.old_rect.size
if not (names_are_synchronized() and sizes_are_synchronize()) and self.image_name != "":
self.image = load_image(self.image_name, size=self.rect.size)
self.refresh()
self.old_image_name = self.image_name
Element.update(self)
return
def __init__(self, click_rect=None, is_clicked=False,
click_duration=DEFAULT_BUTTON_CLICK_DURATION,
**kwargs):
Element.__init__(self, **kwargs)
self.click_rect = click_rect
self.is_clicked = is_clicked
self.old_is_clicked = None
if not self.click_rect:
self.click_rect = self.rect
self.click_duration = click_duration
self.click_time_end = None
return
def update(self):
Element.update(self)
if not self.click_rect:
self.click_rect = self.rect
if self.is_mouse_clicking():
self.click()
if self.is_clicked and self.click_time_end and \
current_time_in_ms() > self.click_time_end:
self.unclick()
if self.old_is_clicked is None or self.is_clicked != self.old_is_clicked:
self.old_is_clicked = self.is_clicked
self.refresh()
return
def calcStressStrainElemental(d, A, NodalCoord, Connectivity):
#calculate strains in center of element!
E = Element("Q4")
stress = np.zeros((3, len(Connectivity)))
strain = np.zeros((3, len(Connectivity)))
for e in range(0, len(Connectivity)):
Coord_mat_el = getElementCoordinates(e, NodalCoord, Connectivity)
Elemental_disp = getElementDisplacements(e, d, A)
gradN, detJ = E.G_map(0, 0, Coord_mat_el)
B = get_B_plane_stress(gradN)
strain[:, e] = np.dot(B, Elemental_disp)[:, 0]
stress[:, e] = strain[:, e]
return strain, stress
def ES_K(Coords):
num_nodes = 4 # number of nodes
E = Element("Q4")
# Now to step through K_mat and integrate each element
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
print(len(Coords))
W_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
G_m = E.G_map()
B, Jdet = G_m(x_ip[i], x_ip[j], Coords)
def getInternalForces(Coord_mat_el,sigma):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
fint_pre = np.zeros((1,8))
count = 0
for i in range(len(xIP)):
for j in range(len(xIP)):
gradN, detJ = E.G_map(xIP[i], xIP[j], Coord_mat_el)
B = get_B_plane_stress(gradN)
fint_pre += np.dot(np.transpose(B),sigma[:,count]) * detJ * weights[i] * weights[j]
count += 1
return np.transpose(fint_pre)
def update(self):
if self.element or self.old_element:
if (not self.old_element) or (not self.element) or \
(self.element != self.old_element):
self.refresh()
if self.element:
self.element.update()
self.rect = self.element.rect
for dirty_rect in self.element.dirty_list:
self.dirty_list.append(dirty_rect)
self.element.dirty_list = []
self.old_element = self.element
Element.update(self)
return
def F_GRAV(trac):
f_grav = np.zeros((8, 1))
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
for k in range(len(xIP)):
s = xIP[k]
N = E.N(s, s)
J_s = np.matrix(detJsideQ4(s, s))
n_mat = np.matrix(N.transpose())
trac_mat = np.matrix(trac)
f_grav += n_mat * trac_mat * J_s[0, k] * weights[k]
return f_grav
def update(self):
if self.old_bold != self.bold or self.old_italic != self.italic or \
self.old_font_size != self.font_size or self.old_font_type != self.font_type:
self.reset_font()
elif self.old_text is None or self.old_text != self.text or \
self.old_font_colour != self.font_colour:
self.refresh()
self.old_text = self.text
self.old_bold = self.bold
self.old_italic = self.italic
self.old_font_colour = self.font_colour
self.old_font_size = self.font_size
self.old_font_type = self.font_type
Element.update(self)
return
def __init__(self, driver):
self.top_item = ElementsList(driver, 'a.nav-menu-item__level-1')
self.sub_item = ElementsList(driver,
'.navigation-nav__subMenuOverLink')
self.head_title_item = Element(driver, '.navigation-nav__HeadTitle')
self.tabs = ElementsList(
driver,
'[data-component="SBIS3.CONTROLS.TabButtons"] .controls-TabButton')
self.controls = ElementsList(driver,
'[data-component^="SBIS3.CONTROLS"]')
self.input_controls = ElementsList(
driver, '[data-component^="SBIS3.CONTROLS"] input')
self.error_txt = Element(driver, '.ws-smp-header')
self.error_2_txt = Element(driver, '.controls-SubmitPopup__message')
self.error_3_txt = Element(driver, '.error-page')
def elements(self):
""" Return the list of valid elementsfor the current report suite """
if self.account.cache:
data = self.request_cached('Report', 'GetElements')
else:
data = self.request('Report', 'GetElements')
return Element.list('elements', data, self, 'name', 'id')
def Dif_basic_K(Coords, k=1): #let k be an optional arguement
E = Element("Q4")
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
W_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
G_m = E.G_map()
B, Jdet = G_m(x_ip[i], x_ip[j], Coords)
B_T = np.transpose(B)
Ke = Ke + B_T.dot(B) * k * Jdet * W_ip[i] * W_ip[j]
return Ke
def getMassMatrix(C):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
Me = np.zeros((8, 8))
me(xIP, C, Me, E)
return Me
def elements(self):
""" Return the list of valid elementsfor the current report suite """
if self.account.cache:
data = self.request_cached('Report', 'GetElements')
else:
data = self.request('Report', 'GetElements')
return Element.list('elements', data, self, 'name', 'id')
def getStiffnessmatrix(C, D, thickness, el_epsilon, pt):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
Ke = np.zeros((8, 8))
ke(xIP, C, D, el_epsilon, pt, weights, thickness, E, Ke)
return Ke
def mouseRelease(self, actor, event):
if self.itemDragging:
element = Element(type(self.pendingActor))
# Copy pendingActor's properties to the element
element.loadProperties(self.pendingActor)
self.model.addElement(element, self.elements.keys()[self.elements.values().index(self.parentActor)])
# Override and set the currently created actor as the proxy
self.elements[element] = self.pendingActor
elif self.selectionBox:
# Process selection
selectionBox = self.selectionBox
self.selectionBox.fadeOut(lambda x:
self.overlayLayer.remove_child(selectionBox))
self.resetDrag()
def getStrainElement(Coord_mat_el, d):
E = Element("Q4")
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
epsilon = np.zeros((3, 4))
count = 0
for i in range(len(xIP)):
for j in range(len(xIP)):
gradN, detJ = E.G_map(xIP[i], xIP[j], Coord_mat_el)
B = get_B_plane_stress(gradN)
val = np.dot(B, d)
for k in range(3):
epsilon[k, count] = val[k]
count += 1
return epsilon
def getdkdumatrix(C, D_prime, thickness, el_sigma):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
Ke = np.zeros((8, 8))
ke_prime(xIP, C, D_prime, el_sigma, weights, thickness, E, Ke)
return Ke
def __init__(self, font_type="Monospace", font_colour=BLACK, text="", \
font_size = 20, bold=False, italic=False, **kwargs):
Element.__init__(self, **kwargs)
self.font_type = font_type
self.old_font_type = font_type
self.font_colour = font_colour
self.old_font_colour = font_colour
self.text = text
self.old_text = None
self.bold = bold
self.old_bold = bold
self.italic = italic
self.old_italic = italic
self.font_size = font_size
self.old_font_size = font_size
self.font = load_system_font(font_type, self.font_size, bold, italic)
return
def MatrixT(Coords, Coefficients, Upwinded):
E = Element('S2')
Ke = np.zeros((2, 2))
#x_ip = [-np.sqrt(3)/3,np.sqrt(3)/3]
#weights = [1,1]
x_ip = [0]
weights = [2]
h = (Coords[1][0] - Coords[0][0])
Jdet = h / 2
a = Coefficients[0]
for i in range(len(x_ip)):
N = E.N(x_ip[i])
N_T = N.transpose()
B = E.G(x_ip[i], Coords)
B_T = B.transpose()
Ke += a * N_T * B * Jdet * weights[i] + (
h / 2) * a * B_T * B * Jdet * weights[i]
return Ke
def Dif_basic_F(el_type, S, Coords, P_type='scalar'):
El = Element('Q4')
if el_type == 'Q4':
num_nodes = 4
elif el_type == 'Q8':
num_nodes = 8
else:
print('Please enter a valid element type')
G = El.G() # snag B-matrix for element
if (P_type == 'scalar'
): # calculates B function based on scalar or vector problem!
B = G
elif (P_type == 'vector'):
B = np.zeros((3, 8))
for i in range(2 * num_nodes):
B[0, 2 * i] = G[0, i]
B[1, 2 * i - 1] = G[1, i]
B[2, 2 * i] = G[0, i]
B[2, 2 * i - 1] = G[1, i]
else:
print('Please enter valid problem type')
F = np.zeros(len(Coords))
N = El.N() # snag B-matrix for element
J = lambda x, y: np.dot(G(x, y), Coords)
J_d = lambda x, y: np.linalg.det(J(x, y))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
w_ip = [1, 1]
for i in range(len(x_ip)):
N_val = N(x_ip[i], x_ip[i])
J_d_val = J_d(x_ip[i], x_ip[i])
S_val = S(x_ip[i], x_ip[i])
F = F + np.dot(np.transpose(N_val), S_val * J_d_val * w_ip[i])
#reference file
file = open('../outputs/f_elemental.txt', 'w')
for i in range(4):
if i != 0:
file.write('\n')
file.write(str(F[0, i]))
file.write(" ")
file.close()
return F
def MatrixT2D(Coords, n, Coefficients, el_type, Upwinded):
E = Element(el_type)
Te = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
weights = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], 0)
N_T = N.transpose()
B, Jdet, G, J_inv = E.G_ext(x_ip[i], x_ip[j], 0, Coords)
B_T = B.transpose()
Te += N_T * np.dot(n, B) * Jdet * weights[i] * weights[j]
if Upwinded == True:
x_coord = np.array([Coords[:, 0]]) @ N.transpose()
y_coord = np.array([Coords[:, 1]]) @ N.transpose()
delta = CalcDelta2D(Coefficients, [x_coord, y_coord], n)
Te += delta * np.dot(B_T, n.transpose()) * np.dot(
n, B) * Jdet * weights[i] * weights[j]
return Te
class ProductPage(BasePage):
def __init__(self, context):
super().__init__(context)
self.add_to_cart_button = Element(By.NAME, 'add_cart', context)
self.pdp_title = Element(
By.XPATH, '//h3[contains(@class, "pdp__title")]/parent::div',
context)
def add_product_to_cart(self):
self.add_to_cart_button.click()
def check_if_pdp_title_contains_text(self, text):
self.pdp_title.is_element_visible()
title = self.pdp_title.text()
if text not in title:
raise Exception(
f'PDP title: {title} does not contain text: {text}')
def VectorF(Coords, Coefficients, sourceFunc, Upwinded):
E = Element("S2")
#x_ip = [-np.sqrt(3)/3,np.sqrt(3)/3]
#weights = [1,1]
x_ip = [0]
weights = [2]
f_ele = np.zeros((2, 1))
h = (Coords[1][0] - Coords[0][0])
Jdet = h / 2
a = Coefficients[0]
for i in range(len(x_ip)):
N = E.N(x_ip[i])
N_T = N.transpose()
B = E.G(x_ip[i], Coords)
B_T = B.transpose()
x_coord = np.dot(np.array([Coords[:, 0]]), N.transpose())
source = SourceTerm(Coords, Coefficients, sourceFunc)
f_ele += N_T * source * Jdet * weights[
i] #+ (h/2)* a * B_T *source * Jdet * weights[i]
return f_ele
def __init__(self, context):
self.context = context
# MENU OPTIONS
self.login_button = Element(
By.XPATH, '//div[contains(@class, "header-menu__logged-out")]',
context)
self.cart_icon = Element(
By.XPATH, '//div[contains(@class,"js-cart-menu-container")]',
context)
self.go_to_checkout_button = Element(
By.XPATH, '//a[contains(text(),"Go to Checkout")]', context)
self.cookie_button = Element(By.XPATH,
'//input[@value="Agree and Proceed"]',
context)
self.country_modal_accept_button = Element(
By.XPATH, '//a[contains(text(),"I understand")]', context)
def MatrixK2D(Coords, n, Coefficients, el_type, Upwinded):
E = Element(el_type)
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
weights = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], 0)
N_T = N.transpose()
B, Jdet, G, J_inv = E.G_ext(x_ip[i], x_ip[j], 0, Coords)
B_T = B.transpose()
x_coord = np.array([Coords[:, 0]]) @ N_T
y_coord = np.array([Coords[:, 1]]) @ N_T
kappa_and_sigma = (Coefficients[0](x_coord, y_coord) +
Coefficients[3](x_coord, y_coord))
Ke += N_T * (kappa_and_sigma) * N * Jdet * weights[i] * weights[j]
if Upwinded == True:
delta = CalcDelta2D(Coefficients, [x_coord, y_coord], n)
Ke += delta * np.dot(B_T, n.transpose(
)) * kappa_and_sigma * N * Jdet * weights[i] * weights[j]
return Ke
class BasePage:
URL = ""
def __init__(self, context):
self.context = context
# MENU OPTIONS
self.login_button = Element(
By.XPATH, '//div[contains(@class, "header-menu__logged-out")]',
context)
self.cart_icon = Element(
By.XPATH, '//div[contains(@class,"js-cart-menu-container")]',
context)
self.go_to_checkout_button = Element(
By.XPATH, '//a[contains(text(),"Go to Checkout")]', context)
self.cookie_button = Element(By.XPATH,
'//input[@value="Agree and Proceed"]',
context)
self.country_modal_accept_button = Element(
By.XPATH, '//a[contains(text(),"I understand")]', context)
def open(self):
self.context.browser.get(self.context.base_e2e_url + self.URL)
def click_login_button(self):
self.login_button.click()
def accept_cookie(self):
self.cookie_button.click()
def accept_country_modal(self):
self.country_modal_accept_button.click()
def go_to_checkout(self):
self.cart_icon.mouse_hoover()
self.go_to_checkout_button.click()
class CartPage(BasePage):
def __init__(self, context):
super().__init__(context)
self.delete_product_icon = Element(By.ID, 'id_form-0-DELETE', context)
self.confirm_deleting_product_button = Element(
By.XPATH, '//button[contains(text(), "Confirm")]', context)
self.cart_content = Element(By.XPATH,
'//div[@class="checkout__main-content"]',
context)
self.empty_cart_message = Element(
By.XPATH,
'//p[contains(@class, "checkout-container__headline-empty")]',
context)
self.empty_cart_message_text = 'Your cart is empty'
def click_delete_product_icon(self):
self.delete_product_icon.click()
def remove_products_from_cart(self):
self.click_delete_product_icon()
self.confirm_deleting_product_button.click()
def check_if_cart_is_not_empty(self):
self.cart_content.is_element_visible()
assert_that(self.cart_content.is_element_visible(), equal_to(True),
'Cart is empty!')
def check_empty_cart_message(self):
self.empty_cart_message.is_element_visible()
message = self.empty_cart_message.text()
assert_that(
message, equal_to(self.empty_cart_message_text),
f'Message text {message} is not equal to expected text: {self.empty_cart_message_text}'
)
def __init__(self, context):
super().__init__(context)
self.delete_product_icon = Element(By.ID, 'id_form-0-DELETE', context)
self.confirm_deleting_product_button = Element(
By.XPATH, '//button[contains(text(), "Confirm")]', context)
self.cart_content = Element(By.XPATH,
'//div[@class="checkout__main-content"]',
context)
self.empty_cart_message = Element(
By.XPATH,
'//p[contains(@class, "checkout-container__headline-empty")]',
context)
self.empty_cart_message_text = 'Your cart is empty'
def __init__(self, context):
super().__init__(context)
self.email_field = Element(
By.NAME, 'username', context
)
self.password_field = Element(
By.NAME, 'password', context
)
self.next_button = Element(
By.ID, 'idp-discovery-submit', context
)
self.login_button = Element(
By.ID, 'okta-signin-submit', context
)
def update(self):
Element.update(self)
self.started = self.is_started()
self.finished = self.is_finished()
return
def draw(self, screen):
Element.draw(self, screen)
location = (self.rect.x, self.rect.y)
self.font.render_to(screen, location, self.text, self.font_colour)
return
def elements(self):
data = self.request('ReportSuite', 'GetAvailableElements')[0]['available_elements']
return Element.list('elements', data, self, 'display_name', 'element_name')
def __init__(self, points=[], colour=BLACK, **kwargs):
Element.__init__(self, **kwargs)
self.points = points
self.colour = colour
return
def _render(self):
self.element = Element(self.haml, self.attr_wrapper)
self.django_variable = self.element.django_variable
self.before = self._render_before(self.element)
self.after = self._render_after(self.element)
self._render_children()
class ElementNode(HamlNode):
'''Node which represents a HTML tag'''
def __init__(self, haml):
HamlNode.__init__(self, haml)
self.django_variable = False
def _render(self):
self.element = Element(self.haml, self.attr_wrapper)
self.django_variable = self.element.django_variable
self.before = self._render_before(self.element)
self.after = self._render_after(self.element)
self._render_children()
def _render_before(self, element):
'''Render opening tag and inline content'''
start = ["%s<%s" % (self.spaces, element.tag)]
if element.id:
start.append(" id=%s" % self.element.attr_wrap(self.replace_inline_variables(element.id)))
if element.classes:
start.append(" class=%s" % self.element.attr_wrap(self.replace_inline_variables(element.classes)))
if element.attributes:
start.append(' ' + self.replace_inline_variables(element.attributes))
content = self._render_inline_content(self.element.inline_content)
if element.nuke_inner_whitespace and content:
content = content.strip()
if element.self_close and not content:
start.append(" />")
elif content:
start.append(">%s" % (content))
elif self.children:
start.append(">%s" % (self.render_newlines()))
else:
start.append(">")
return ''.join(start)
def _render_after(self, element):
'''Render closing tag'''
if element.inline_content:
return "</%s>%s" % (element.tag, self.render_newlines())
elif element.self_close:
return self.render_newlines()
elif self.children:
return "%s</%s>\n" % (self.spaces, element.tag)
else:
return "</%s>\n" % (element.tag)
def _post_render(self):
# Inner whitespace removal
if self.element.nuke_inner_whitespace:
self.before = self.before.rstrip()
self.after = self.after.lstrip()
if self.children:
node = self
# If node renders nothing, do removal on its first child instead
if node.children[0].empty_node == True:
node = node.children[0]
if node.children:
node.children[0].before = node.children[0].before.lstrip()
node = self
if node.children[-1].empty_node == True:
node = node.children[-1]
if node.children:
node.children[-1].after = node.children[-1].after.rstrip()
# Outer whitespace removal
if self.element.nuke_outer_whitespace:
left_sibling = self.left_sibling()
if left_sibling:
# If node has left sibling, strip whitespace after left sibling
left_sibling.after = left_sibling.after.rstrip()
left_sibling.newlines = 0
else:
# If not, whitespace comes from it's parent node,
# so strip whitespace before the node
self.parent.before = self.parent.before.rstrip()
self.parent.newlines = 0
self.before = self.before.lstrip()
self.after = self.after.rstrip()
right_sibling = self.right_sibling()
if right_sibling:
right_sibling.before = right_sibling.before.lstrip()
else:
self.parent.after = self.parent.after.lstrip()
self.parent.newlines = 0
super(ElementNode, self)._post_render()
def _render_inline_content(self, inline_content):
if inline_content == None or len(inline_content) == 0:
return None
if self.django_variable:
content = "{{ " + inline_content.strip() + " }}"
return content
else:
return self.replace_inline_variables(inline_content)
def __init__(self, image_name="", **kwargs):
Element.__init__(self, **kwargs)
self.image_name = image_name
self.old_image_name = None
self.image = None
return
def __init__(self, **kwargs):
Element.__init__(self, **kwargs)
self.started = False
self.finished = False
return
def __init__(self, element=None, **kwargs):
Element.__init__(self, **kwargs)
self.element = element
self.old_element = None
return
def elements(self):
""" Return the list of valid elementsfor the current report suite """
data = self.request('Report', 'GetElements')
return Element.list('elements', data, self, 'name', 'id')
def draw(self, screen):
Element.draw(self, screen)
if self.element:
self.element.draw(screen)
return
def __init__(self, datas=None):
super(List, self).__init__()
UserList.__init__(self)
Element.__init__(self)
self.data = isinstance(datas, list) and datas or []
self._text = None
def __init__(self, colour=BLACK, thickness=0, **kwargs):
Element.__init__(self, **kwargs)
self.colour = colour
self.thickness = thickness
return
