Location>code7788 >text

The first study notes in the province of the Automation Test Competition (functional test not studied)

Popularity：510 ℃/2025-02-28 22:55:10

Environment configuration

Linux related
[[Bird Linux Basics]]
[[Linux command line and shell script programming collection]]

>centos without network, use virtualBox NAT connection
 Solution 1:
 1. Switch to root
 2. cd to /etc/sysconfig/network-scripts/
 3. vi edit ifcfg-enp0s3 file
 4. HWADDR=00:00:00:00 (This is replaced by MAC address) ONBOOT=no is changed to yes, add BOOTPROTO=dhcp
 5. Restart the network service network restart

 Solution 2:
 1. vi /etc/
 2. Add a line of nameserver followed by the host address, here is the DNS server

Configure JDK

Centos system comes with OpenJDK. If you need to install other versions, you may need to uninstall it first.

[test@localhost ~]$ java -version
openjdk version "1.8.0_262"
OpenJDK Runtime Environment (build 1.8.0_262-b10)
OpenJDK 64-Bit Server VM (build 25.262-b10, mixed mode)

Uninstall OpenJDK

rpm -qa | grep java//Query related java suite
 // You don't need to worry about the .noarch file
 rpm -e --nodeps java file

rpm installation
Generally, there is no need to manually configure environment variables becauserpmThe necessary paths will be automatically added to the system's environment variables during the package installation process.

# rpm package installation command
 rpm -ivh full name
 Options:
     -i(install) Install
     -v(verbose) Show details
     -h(hash) Show progress
     --nodeps does not detect dependencies

Install

# Unzip gz compressed package
 tar -zxvf package full name
 Options:
	 -z: Filter archive files via gzip for processing .gz compressed files
	 -x: Extract files
	 -v: Show details
	 -f: Specify the name of the archive file
 # Create a folder
 mkdir -p
 # Copy jdk to the folder created in the previous step
 cp -r

 # Edit global variable file
 vim /etc/profile
 export JAVA_HOME=jdk directory
 export JRE_HOME=$JAVA_HOME/jre
 export PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin

 # Make the configuration file effective
 source /etc/profile

Configure Mysql5.7

Mysql related
[[MySQL Basics]]

Install

Environmental inspection

// Check whether there is a mysql process
 ps ajx | grep mysql
 // Check if there is a mariabd process
 ps ajx | grep mariabd
 //If you find that there is a process running, you need to close the process
 systemctl stop mysqld
 // Check if there is an installation package
 rpm -qa | grep mysql
 //If there is an installation package and you have not used MySQL before, then delete these installation packages
 //Batch delete installation package
 rpm -qa | grep mysql | xargs yum -y remove
 //Check if there is a configuration file
 ls /etc/
 //Delete the configuration file
 rm -rf /etc/

Installation configuration

//Decompression
 tar -zxvf
 //Create a user group
 groupadd mysql
 /*
 The -r option means to create a system user. The system user is usually not logged into the shell. They are usually used to run the service.
 -g mysql option specifies that the main group of the new user is mysql, and this group must already exist
 The -s /bin/false option specifies that the user's login shell is /bin/false. This is a fake shell, which means that the user cannot log in to the system through a password.
 mysql is the username of the new user
 */
 useradd -r -g mysql -s /bin/false mysql
 /*
 Change the current directory and its subdirectories and file ownership to user mysql and group mysql
 -R means recursive change
 */
 chown -R mysql:mysql.

 //Install mysql, the path changes according to actual situation
 ./bin/mysqld --user=mysql --basedir=/opt/mysql --datadir=/opt/mysql/data --initialize
 //Modify MySQL configuration file
 vi /etc/
 //Open mysql
 ./support-files/ start

 //Configure environment variables
 export PATH=$PATH:/opt/mysql/bin
 //Put the mysql process into the system process
 cp support-files/ /etc//mysqld
 //Restart mysql service
 service mysqld restart

 //Login the mysql database with a random password
 mysql -u root -p
 //Change the password of the user named root whose login address is localhost to 123456
 alter user 'root'@'localhost' identified by '123456';
 //Set the host field of the user whose username is root to % means connecting to the MySQL server from any host, not just from localhost
 use mysql;
 user SET Host = '%' WHERE User = 'root';
 //View the modified value
 select user,host from user;
 //Refresh permissions
 flush privileges;

 //Make sure the firewall allows MySQL's default port (3306) to pass
 firewall-cmd --zone=public --add-port=3306/tcp --permanent
 firewall-cmd --reload

document

[mysqld]
port=3306
basedir=/opt/mysql
datadir=/opt/mysql/data
socket=/opt/mysql/
character-set-server=utf8
symbolic-links=0
bind_address=0.0.0.0

[mysqld_safe]
log-error=/opt/mysql/mariadb/log/
pid-file=/opt/mysql/mariadb/run/

[client]
socket=/opt/mysql/
default-character-set=utf8

!includedir /etc/

Configuring the deployment of Tomcat and war packages

Configure tomcat

//Enter into bin
 ./ //Open
 ./ //closure

 //View all open ports in the system
 firewall-cmd --zone=public --list-ports
 //Open port 8080
 firewall-cmd --zone=public --add-port=8080/tcp --permanent
 //Restart the firewall
 systemctl restart

Python Basics

Output

n=100
 print("one:%d"%n) #Integer d
 n=33.333
 print("two:%f"%n) #Floating point number f
 n="sss"
 print("three:%s"%n) #String s
 n = { 1, 2, 3 }
 print("four:%r"%n) #Universal r, outputs the original representation

 #f-string string formatting, similar to string interpolation
 age=18
 name="root"
 print(f"my name is {name}, my age is {age}")

 # method, format control characters are usually included in braces {} and can be used with named parameters or position parameters.
 template = "Integer: {}, Float: {:.2f}, String: {}"
 print((123, 45.6789, "hello"))

print()There is an optional parameterend=, can be specified as an empty string''There will be no line breaks, it can be set to other characters or strings to add custom delimiters after output

enter

While (1):
     try:
         age = int(input("Please enter your age:"))
         print(f"Your age is: {age} years old")
         break
     except ValueError:
         print("Sorry, you entered not a valid age. Please re-enter an integer")

Type conversion

#Convert to float
 height = float(input("Please enter your height (meter):")
 print(f"Your height is: {height} meters")

[!hint]

  • Python does not distinguish between single and double quotes, both of which represent a string
  • Single and double quotes can be used in nested ways, but not cross-used.
  • Single line comment #, multi-line comment three pairs of quotes, no distinction between odd and double quotes
  • Python uses curly braces to represent the statement body, and uses statement indentation to judge the statement body

Python string operators

str1 + str2 # string concatenation
 str * n #repeat string n times
 [] #Index to get characters in strings, you can also use colons to get some characters
 str in a # string contains the given character
 str not in a # string does not contain the given character
 r/R"str" ​​#Let the string output without escape

Format strings and built-in functions self-check

Branch and loop structure

if statement

a = 1
 b = 2
 if a > b:
     print("a max!")
 else:
     print("b max!")

 #Multiple condition judgment, cannot use else if, use elif
 results = 99
 if results >= 90:
     print('Excellent')
 elif results >= 70:
     print('good')
 elif results >= 60:
     print('pass')
 else:
     print('Failed')

Tripartite Expressions

x = 10  
y = "positive" if x > 0 else "non-positive"  
print(y)

for statement

#Transfer strings, only one statement can be written on one line
 for i in "hello world": print(i, end = '')

 #Transfer through the array (list)
 fruits=['banana', 'apple', 'mango']
 for fruit in fruits: print(fruit)

If you need to perform a certain number of cycles, you need to use therange()function

for i in range(5, 10, 2): print(i, end = ' ')

range()The first parameter is the start position, the second parameter is the end position, the third parameter is the loop step size, and the last two parameters are optional parameters

If you just want to loop without caring about the index or value of each iteration:

for _ in range(5): print("Hello World")

_It is just a normal variable name, and it can also be replaced by other variable names. It just means that according to programming convention, it means that a placeholder means that the variable will not be used.

Array (list)
Arrays are represented by square brackets, each item is separated by commas, the array subscript starts from zero, Python calls the array a list

#Python list built-in method
 append(x) #Add an element at the end of the list
 extend(x) #Add all elements of another list to the list
 insert(i, x) #Insert element at the specified position
 remove(x) #Remove the first element in the list with x value
 pop([i]) #Remove and return the element at the specified position in the list. Unspecified position is removed by default and returns the last element
 clear() #Remove all elements of the list
 index(x, strat,stop) #Returns the index of the first element with the value x, then as optional parameters, specify the range search
 count(x) #Returns the number of elements with a value of x in the list
 sort(key=,reverse=) #Sort the list in place, all are optional parameters, key specifies a function, which will be applied to each element before sorting.  This allows you to sort based on a certain attribute of the element or converted value. Reverse Boolean value, true in descending order, and default false in ascending order
 reverse() #Reverse()
 copy() #Returns a shallow copy of the list

You can use the subscript index to access the values ​​in the list. You can also use square brackets to intercept characters.

list = ['physics', 'chemistry', 1997, 2000, 1, 2]
 print("list[1:3]: ", list[1:3])# does not contain 3
 #1 to the end
 for i in list[1:]:
     print("list[1:4]: ", i)
 #Negative number is inverse reading, -1 is the last element

List pair+and*The operator is similar to a string,+Combination list,*Repeat list

print(3 in list) #Is the element in the list
 len(list) #list length

dictionary
The dictionary uses curly braces to represent (that is, key-value pairs), a key corresponds to a value, separated by colons, and commas are separated by different items.

Python stipulates that the key in a dictionary must be unique and the value can be the same

#Python Dictionary Built-in Method
 clear() #Clear all items in the dictionary
 copy() #Return to the dictionary shallow copy
 fromkeys(seq,value) #Create a new dictionary, use elements in the sequence seq as dictionary, value is an optional parameter, which is the initial value corresponding to all keys of the dictionary
 get(key,default) #Returns the value of the specified key. If the key does not exist, return the default value. If the default is not specified, return None
 items() #Returns a view object containing all key-value pairs in the dictionary
 keys() #Returns a view object containing all keys in the dictionary
 values() #Returns a view object containing all values ​​in the dictionary
 pop(key,default) #Remove and return the element at the specified position in the list. Unspecified position is removed by default and returns the last element. default is an optional parameter
 popitem() #Randomly remove a pair of key-value pairs from the dictionary and return as a tuple. If the dictionary is empty, a KeyError exception is thrown
 setdefault(key,default) #If the key does not exist, insert the key and set the value to default, return its value if it already exists.  The default value of default is None
 update() #Update the dictionary with key-value pairs of another dictionary

Tuples
The element of the Yuanzu cannot be modified. The Yuanzu is created using parentheses, separated by commas. When the tuple contains only one element, a comma needs to be added after the element.

Tuples are similar to strings. The subscript index starts from 0 and can be intercepted, combined, etc.

The element values ​​in tuples are not allowed to be modified, but tuples can be combined.

tup1 = (12, 34.56)
 tup2 = ('abc', 'xyz')
 #Modifying tuple element operations is illegal
 tup1[0] = 100
 #Create a new tuple
 tup3 = tup1 + tup2
 print(tup3)

[!caution]
delStatements are used in Python to delete objects. It can be used to delete variables, elements in lists, key-value pairs in dictionaries, and even entire objects (such as lists or dictionaries)
delStatements are used to unbind one or more objects and their names.

The element value in the tuple cannot be modified, but can be useddelDelete the entire tuple

del tup3

Like strings, tuples can be used between+Number and*. This means they can be combined and copied, and a new tuple will be generated after the operation

#Built-in Tuples
 cmp(tuple1, tuple2) #Compare two tuple elements
 len(tuple) #Count the number of tuple elements
 max(tuple) #Returns the maximum value of the element in the tuple
 min(tuple) #Returns the minimum value of the element in the tuple
 tuple(seq) #Convert list to tuple

function
defKeyword definition, followed by function identifier and parentheses

Use keyword arguments to allow the order of parameters when calling a function is inconsistent with the declaration because the Python interpreter can match parameter values ​​with parameter names

function(agr=2,str="meet")

 #Default Parameters
 def function(name, age = 12):

 #Indefinite length parameters, variable names with asterisks will store all unnamed variable parameters
 def printinfo( arg1, *vartuple):
  print("Output: ")
  print(arg1)
  for var in varuple: print(var)

Python uses lambda expression to create anonymous functions, including only one statement

# Assign it to a variable to use as a function, why is this so similar to the delegate of C#
 sum = lambda arg1, arg2: arg1 + arg2
 # Call the sum function
 print("The added value is: "), sum( 10, 20 )
 print("The added value is: "), sum( 20, 20 )

Types in Python belong to objects, variables have no types

a = [1, 2, 3]
a = 'Apple'

[1,2,3]It's list type,'Apple'It is a String type, variable a has no type, it is just a reference to an object (pointer)

Parameter passing of python functions:

  • Immutable Type: Passing values ​​similar to c++, such as integers, strings, and tuples, only the value copy is passed, not the itself

  • Variable Type: C++-like reference passing, such as lists, dictionaries, and the object itself

Classes and methods
classKeyword creation class

class A(object):
 #Create a class A, the default inheritance object is also possible without explicitly declaring inheritance

The only difference between a method and a function is that the first parameter of a method must exist, and is generally namedself, but you do not need to pass a value for this parameter when calling this method

Generally, when creating a class, the initialization method will be declared first.__init__()

class A():
	def__init__(self, a, b):
	 =int(a)
	 =int(b)

It's the constructor

Module
That is, a class library, a module will only be imported once, no matter how many times it is executedimport. This prevents the import module from being executed over and over again

#Introduce modules or functions in modules
 import module.function
 #Import a specified part from the module into the current namespace
 from module import function 1, function 2
 from module import * #Import all contents of this module into the current namespace

The module search path is stored insystemModularin variable. The variable contains the current directory, PYTHONPATH and the default directory determined by the installation process.

Python standard exception
BaseException Base class for all exceptions
SystemExit Interpreter request exit
KeyboardInterrupt User interruption execution (usually input ^C)
Exception Base class for general errors
StopIteration The iterator has no more values
GeneratorExit An exception occurred to notify the exit of the generator.
StandardError All built-in standard exception base classes
ArithmeticError All numerical calculation errors
FloatingPointError Floating point calculation error
OverflowError Numerical operations exceed maximum limit
ZeroDivisionError Divide (or modulo) zero (all data types)
AssertionError Assertion statement failed
AttributeError The object does not have this property
EOFError No built-in input, reach the EOF mark
EnvironmentError Base class for operating system errors
IOError Input/output operation failed
OSError Operating system errors
WindowsError System call failed
ImportError Failed to import module/object
LookupError Base class for invalid data query
IndexError There is no index in the sequence (index)
KeyError There is no key in the map
MemoryError Memory overflow error (not fatal for Python interpreters)
NameError Undeclared/initialized object (no attributes)
UnboundLocalError Access uninitialized local variables
ReferenceError Weak reference attempts to access objects that have been garbage collected
RuntimeError General runtime errors
NotImplementedError Methods not implemented yet
SyntaxError Python syntax error
IndentationError Indentation error
TabError Mix Tab and spaces
SystemError General interpreter system errors
TypeError Invalid operation on type
ValueError Passing invalid parameters
UnicodeError Unicode-related errors
UnicodeDecodeError Errors during Unicode decoding
UnicodeEncodeError Unicode encoding error
UnicodeTranslateError Unicode conversion error
Warning Base class of warnings
DeprecationWarning Warnings about deprecated features
FutureWarning Warnings about the future semantic changes in construction
OverflowWarning Old warning about automatic promotion to long
PendingDeprecationWarning Warning about the feature being discarded
RuntimeWarning Warning of suspicious runtime behavior
SyntaxWarning Warnings of suspicious grammar
UserWarning User code generation warning

Except inexceptUsed in, can also be usedraiseThe statement throws an exception

raise exception type (can be attached value, usually used to describe the cause of the exception)

Unit Test Junit Framework

JUnit4 annotation

  • @Test:The annotation method is a test method, and the JUnit runner will execute the execution marked with@TestAll methods of annotation
    • expected=Specifies the expected exception. If the test method throws the specified exception, the test passes; otherwise, the test fails
    • timeout=Used to specify the maximum run time in milliseconds for the test method. If the test method is not completed within the specified time, the test fails
  • @Before:Execute before each test method. Used to initialize the test environment
  • @After: Execute after each test method. Used to clean up the test environment
    ![[Pasted image ]]
  • @BeforeClass: Execute only once before all test methods. Used to perform one-time initialization, such as database connection
  • @AfterClass: Execute only once after all test methods. Used to perform a one-time cleanup, such as closing a database connection
    ![[Pasted image ]]
  • @Ignore: Ignore a test method or test class. Ignored tests will not be executed by the JUnit runner

Parameterized testing

Allow the same test to be run repeatedly with different values, and follow 5 steps to create parameterized tests
 1. Specify the test runner using the `@RunWith()` annotation
 2. Create a public static method annotated by `@Parameters`, which returns a collection of objects (arrays) as a test data collection
 3. Create a public constructor that accepts something equivalent to a line of test data
 4. Create an instance variable for each column of test data
 5. Create your test cases using instance variables as the source of test data
  • @RunWith():Use on a test class@RunWith()When annotating, tell JUnit to useParameterizedThe runner executes all test methods in this test class. This runner knows how to handle parameterized tests, i.e. it will be@ParametersCreate a test instance for each set of data provided by the annotation method and run the test method for each instance.
  • @Parameters:This annotation is used to define the data for parameterized tests. It modifies a static method, which returns aCollection<Object[]>A collection of types of data, each of whichObject[]Contains a set of parameters that will be used to construct an instance of the test class. Usually return a list (such as), which contains multiple arrays, each representing a set of test parameters. These parameters will be used in the order in which they are in the list to create test instances and run the test methods separately
import ;
 import ;
 import static ;

 import ;
 import ;

 import ;
 import ;
 import ;

 @RunWith()
 public class FourFlowChartTest {
	 static FourFlowChart fourFlowChart;
	 @BeforeClass
	 public static void setUP() {
		 fourFlowChart=new FourFlowChart();
	 }
	 private String usernameString;
	 private String passwordString;
	 private String expectedString;
	 public FourFlowChartTest(String u,String p,String e) {
		 =u;
		 =p;
		 =e;
	 }
	 @Parameters
	 public static Collection<Object[]> datas(){
		 return (new Object[][] {
			 {"","","Username or password cannot be empty"},
			 {"admin","123","Login successfully"},
			 {"test","123","Please enter the correct username"},
			 {"admin","1","Please enter the correct password"},
			 {"test","1","Please enter the correct username and password"},
		 });
	 }
	 @Test
	 public void test() {
		 String result=(usernameString, passwordString);
		 assertEquals(expectedString, result);
	 }

 }

useBufferedReaderandFileReaderRead csv file

package test;
 import static ;

 import ;
 import ;
 import ;
 import ;
 import ;
 import ;
 import ;
 import ;
 import ;
 @RunWith()
 public class ReadCSVAddTest {
	 private ReadCSVAdd readCSVAdd=new ReadCSVAdd();

	 private int a;
	 private int b;
	 private int expected;
	 public ReadCSVAddTest(int a,int b,int expected) {
		 =a;
		 =b;
		 =expected;
	 }
	 @Parameters
	 public static Collection<Object[]> datas() throws IOException{
		 ArrayList<Object[]> datas=new ArrayList<>();
		 BufferedReader br=new BufferedReader(new FileReader("F:\\AutoTest\\Eclipse\\code\\code\\review\\junitCode\\test\\"));
		 String line;
	 try {
		 While((line=())!=null)
		 {
			 String[] values=(",");
			 int a=(values[0]);
			 int b=(values[1]);
			 int expected=(values[2]);
			 (new Object[] {a,b,expected});
		 }
	 } finally {
		 ();
	 }
		 return datas;
	 }
	 @Test
	 public void testAdd() {
		 int result=(a, b);
		 assertEquals("Do not meet the addition requirement", result, expected);
	 }
 }

Test suite

A method to batch run test classes

import ;
 import ;

 @RunWith()
 @({//Test class array
 ,

 })
 public class SuiteTest {//Empty class serves as the entrance to the test suite

 }

Rule annotation

import ;
 import ;
 import ;

 public class TestNameExample {
	 @Rule
	 public TestName testName = new TestName();//Get the name of the current test method in the test method
	
	 @Test
	 public void testMethod1() {
		 ("Running test: " + ());
	 }
	
	 @Test
	 public void testMethod2() {
		 ("Running test: " + ());
	 }
 }
import ;
 import ;
 import ;
 import ;
 import ;

 public class TemporaryFolderExample {
	 @Rule
	 public TemporaryFolder temporaryFolder = new TemporaryFolder();//Create temporary files and directories in the test and delete them automatically after the test is finished.  This is very useful for testing that requires file system operations
	
	 @Test
	 public void testCreateFile() throws IOException {
		 File file = ("");
		 ("Created file: " + ());
	 }
	
	 @Test
	 public void testCreateDirectory() throws IOException {
		 File directory = ("testDir");
		 ("Created directory: " + ());
	 }
 }

ExternalResourceIt is a base class provided by JUnit, which is used to perform resource setup and cleaning before and after testing.
Before each test method is executed, it will print "Before test: Setting up resources" and after execution, it will print "After test: Tearing down resources"

import ;
import ;
import ;
  
public class ExternalResourceExample {
	@Rule
	public ExternalResource resource = new ExternalResource() {
		@Override
		protected void before() throws Throwable {
			("Before test: Setting up resources");
		}
		@Override
		protected void after() {
			("After test: Tearing down resources");
		}
	};
	@Test
	public void testMethod1() {
		("Running test method 1");
	}
	@Test
	public void testMethod2() {
		("Running test method 2");
	}
}

JUnit4 Assertion

  • assertEquals(expected, actual): Assert check whether the two values ​​are equal

  • assertEquals(double expected, double actual, double delta): Assertion checks whether two double-precision floating point numbers are equal within the specified error range

  • assertEquals(float expected, float actual, float delta): Assertion checks whether two floating point numbers are equal within the specified error range

  • assertNotNull(Object object): Assert that the check object is not empty

  • assertNull(Object object): Assert the check object is empty

  • assertTrue(boolean condition): Assert check whether the condition istrue

  • assertFalse(boolean condition): Assert check whether the condition isfalse

  • assertSame(Object expected, Object actual): Assertion Checks whether two object references point to the same object

  • assertNotSame(Object expected, Object actual): Assertion Checks whether two object references point to different objects

  • assertArrayEquals(Object[] expecteds, Object[] actuals): Assert check whether two arrays are equal

  • assertArrayEquals(double[] expecteds, double[] actuals, double delta): Assert that two double-precision floating point arrays are equal, allowing for a certain error range

collapse: none
 assertTure and false assertEquals and NotEquals and assertNull and assertNotNull can have the first string parameter to customize the failure information
 `import static .*;` is a package that JUnit4 asserts
 `import static ;`
 `import static .*;` is a package for the Hamcrest test assertion library

Hamcrest test assertion library

  • assertThat(actual,metcher)It is a flexible and readable assertion method provided by Hamcrest.actualis the actual value being tested,matcheris a condition used for matching, as expected
  • assertThat(actual,equalTo(expected)): Check whether the two values ​​are equal
  • assertThat(actual, is(expected)): Used to represent a match where the value should be equal to the given value
  • assertThat(actual, is(not(expected)));: used to indicate that the conditions are not true
int actual = 3;
 int unexpected = 5;
 assertThat(actual, is(not(unexpected))); // Assert succeeds because 3 does not equal 5

  • assertThat(actual, greaterThan(expectedValue));: Check if one number is greater than another number

  • assertThat(actual, lessThan(expectedValue));: Check if one number is smaller than another number

  • emptyStringandnotEmptyString: Check whether the string is empty or not empty

String actualEmpty = "";
 String actualNotEmpty = "Hello";

 assertThat(actualEmpty, is(emptyString())); // Assertion is successful because the string is empty
 assertThat(actualNotEmpty, is(not(emptyString()))); // Assert succeeds because the string is not empty

+assertThat(actual, containsString(expectedSubstring));: Check whether the string contains a substring

String actual = "Hello, World!";
 String expectedSubstring = "World";
 assertThat(actual, containsString(expectedSubstring)); // Assertion is successful because it contains the substring "World"
  • hasItemandhasItems: Check whether the collection contains an element or multiple elements
List<String> collection = ("apple", "banana", "orange");

 assertThat(collection, hasItem("banana")); // Assertion is successful because the collection contains "banana"
 assertThat(collection, hasItems("apple", "orange")); // Assertion is successful because the collection contains both "apple" and "orange"
  • assertThat(array, arrayContaining(expectedElement1, expectedElement2));: Check whether the array contains the specified elements in order
String[] array = {"one", "two", "three"};
 assertThat(array, arrayContaining("one", "two", "three")); // Assertion succeeds because the array contains these elements in order

Automated test script design

Term definition

  1. Automated testing concept: Automated testing is to transform human-driven testing behavior intoMachine executiona process of .
  2. Prerequisites for automated testing: Infrequent demand changes, long enough project cycle, and automated testing scripts canReused。
  3. The process of automated testing: (1) FormulateTest plan, (2) Analyze test requirements, (3) Design test cases, (4) Build a test environment, (5) Write and execute test scripts, (6) Analyze test results and record bugs, (7) Track bugs and conduct regression testing.
  4. Purpose of conducting automated testing: With the development of national computer informatization, software needs to be iterated quickly, such as some repetitive work that can be passedautomationto complete iterations, thereby improving work efficiency and accuracy

First, importseleniumand install browser drivers

from selenium import webdriver
 from import Service
 # Set the path to ChromeDriver
 chromedriver_path = r"path"
  
 # Create Service Object
 service = Service(chromedriver_path)
  
 # Initialize WebDriver
 # () requires drivers to be in environment variables
 driver = (service=service)
 ("")

Simple element operation

()#Clear input content in the text box
 username.send_keys("root")#Simulate the keyboard to enter content into the input box
 ()#Submit the form
 #In addition to this
 .size #Returns the size of the element
 .text #get the text of the element
 .get_attribute(name) #Get attribute value
 .is_displayed() #Whether this element is visible to the user, return a boolean value
 .is_selected() #Judge whether the element is selected
 .is_enabled() #Judge whether the element is editable

useSelectClass to handle drop-down menus

# Find the drop-down menu element
 select_element = driver.find_element(, 'name') # Replace with the NAME attribute of the drop-down menu
 # Create Select object
 select = Select(select_element)
 # Select options by index
 select.select_by_index(1) # Select the second option, the index starts at 0
 # Select options via visible text
 select.select_by_visible_text("Option Text") # Replace with actual visible text
 # Select options by value
 select.select_by_value("option_value") # Replace with the actual value

 select = Select(driver.find_element(,'xpath'))
 select.deselect_all()# Deselect the selected element

 select = Select(driver.find_element(,'xpath'))
 all_selected_options = select.all_selected_options# Get all selected options

Drag and drop
Drag and drop a web page element to another target element

element = driver.find_element_by_name("source")
 target = driver.find_element_by_name("target")
  
 from import ActionChains
 action_chains = ActionChains(driver) # Create a new operation chain object to perform compound operations
 action_chains.drag_and_drop(element, target).perform()# The operation of dragging from the source element to the target element

Basic browser operation method

from time import sleep# import sleep function of time module
 from selenium import webdriver#Import webdriver from selenium module

 #Open the specified browser
 driver = ()
 #Skip to the specified url
 ("")
 #Wait 2 seconds
 sleep(2)
 ("/")
 sleep(2)
 #Back operation
 ()
 sleep(2)
 #Forward operation
 ()
 sleep(2)

()Refresh the page
driver.maximize_window()Maximize the current browser window
()Close the current browser window
()Exit the current browser

Basic element positioning

Format:find_element("")
This method requires two parameters: a positioning strategy (byByclass provides), a value used for the positioning policy (such as the element's ID, class name, label name, etc.)

  • : Positioning elements by the ID attribute value of the element
  • : Positioning elements by the name attribute value of the element
  • By.CLASS_NAME: Position elements by the class name of the element
  • By.TAG_NAME: Position elements by their label name
  • : Position elements through XPath expression. XPath is a language that searches for information in XML documents, and is also suitable for HTML
  • By.CSS_SELECTOR: Position elements through CSS selector. CSS selector is a pattern for selecting HTML elements
  • By.LINK_TEXT: Positioning elements with full link text, usually used for<a>Tags, can be used when page redirection is required
  • By.PARTIAL_LINK_TEXT: Position elements through partial link text
from time import sleep
 from selenium import webdriver
 #Import By class to specify the element search method
 from import By
 #Import the WebDriverWait class for explicit waiting
 from import WebDriverWait
 #Import the expected_conditions module and set an alias EC for it. This module contains a series of predefined waiting conditions
 from import expected_conditions as EC
  
 driver = ()
 ("http://127.0.0.1:5500/webstorm/")


 #If this element appears within 10 seconds, continue execution; otherwise an exception will be thrown
 #presence_of_element_located Check whether an element exists in the DOM
 username=WebDriverWait(driver,10).until(EC.presence_of_element_located((, "username")))
 #Enter text root in the found username input box
 username.send_keys("root")

 password=WebDriverWait(driver,10).until(EC.presence_of_element_located((, "password"))).send_keys("123")

 sleep(3)

The following code is more concise, but usefind_elementMethods without any waiting can cause problems, especially when page elements are loaded dynamically, or when network delay, page rendering speed and other factors cause elements to not yet available when searching

#Find the element with ID username and assign it to the username variable
 username = driver.find_element(, "username")
 #Simulate user text input
 username.send_keys("root")

 driver.find_element(, "password").send_keys("123456")

Waiting is also possible or using implicit waiting

driver.implicitly_wait(10)

When used in subsequent codefind_elementorfind_elementsWhen using the method, WebDriver will constantly try to find elements within a specified time.Until the element is found or timeout
Note that implicit waiting is global and applied to all subsequent element search operations

find_elementsMultiple elements can be located

driver.find_elements(By.TAG_NAME, "input")[0].send_keys("root")  
driver.find_elements(By.TAG_NAME, "input")[1].send_keys("123")

Mouse simulation operation

SeleniumsupplyActionChainsThis class handles events of this class

#Import ActionChains class from SeleniumWebDriver module
 from import ActionChains

 driver = ()
 ("http://127.0.0.1:5500/webstorm/")
  
 username = driver.find_element(, "username")
 #Simulate all operation
 ActionChains(driver).key_down(, username).send_keys("a").key_up().perform()
 sleep(2)

Can also be createdActionchainsExample

actions = ActionChains(driver)
 # Move the mouse to the element and click
 actions.move_to_element(element).click().perform()

 # Or send keyboard input to element
 actions.send_keys("Hello, World!").perform()

.perform()The function is to trigger and execute before passingActionChainsAll actions of object construction

#Suppose the driver is a WebDriver instance and has been navigated to the target page
 element = driver.find_element(, "some-element-id")
  
 # Create ActionChains object
 actions = ActionChains(driver)
  
 # Build an action chain: move the mouse to the element and click
 actions.move_to_element(element).click()
  
 # Execute all actions in the action chain
 ()
  1. click(on_element=None)：
    • Function: Simulate left mouse click event
    • parameter:on_element, the element to be clicked, ifNone, then click the current mouse location, the same below
  2. click_and_hold(on_element=None)：
    • Function: Simulate the left mouse button and keep it unselected
  3. context_click(on_element=None)：
    • Function: Simulate the right-click event of the mouse, usually used to pop up the context menu
  4. double_click(on_element=None)：
    • Function: Simulate the left mouse button double-click event
  5. drag_and_drop(source, target)：
    • Function: Simulates mouse drag operation, drag from the source element to the target element.
    • parameter:source: The starting element of the drag operation;target: The target element of the drag operation
  6. drag_and_drop_by_offset(source, xoffset, yoffset)：
    • Function: Simulate mouse drag operation, starting from the source element, drag to the specified coordinate offset
    • parameter:source: The starting element of the drag operation;xoffset: horizontal offset;yoffset: vertical offset
  7. key_down(value, element=None)：
    • Function: Simulate pressing a key on the keyboard
    • parameter:value: The character or key value of the key to be pressed;element: Optional parameter on which element to perform key operation
  8. key_up(value, element=None)：
    • Function: Simulate to release a key on the keyboard
    • parameter:value: Characters or key values ​​of the key to be released;element: Optional parameter on which element to perform key operation
  9. move_by_offset(xoffset, yoffset)：
    • Function: Move the mouse pointer from the current position the specified offset
    • parameter:xoffset: horizontal offset;yoffset: vertical offset
  10. move_to_element(element)：
    • Function: Move the mouse pointer to the specified element
    • parameter:element: Element to be moved to
  11. pause(seconds)：
    • Function: Pause all inputs, duration in seconds.
    • parameter:seconds: Pause time (units of seconds)
  12. perform()：
    • Function: Perform all actions so that mouse and keyboard operations take effect
  13. reset_actions()：
    • Function: End an existing operation and reset it
  14. release(on_element=None)：
    • Function: Release the left mouse button at an element position.
    • parameter:on_element: The element to be released on it; ifNone, then release it at the current mouse position

Keyboard simulation operation

  1. send_keys(*keys_to_send)：
    • Function: Send a key or enter text to the element in the current focus
    • parameter:*keys_to_send: The key or text to be sent, which can be one or more
  2. send_keys_to_element(element, *keys_to_send)：
    • Function: Send a key to the specified element.
    • parameter:
      • element: The target element to be sent
      • *keys_to_send: The key or text to be sent
        KeysClass basically meets the needs of basic keyboard operations
#Import the Keys class, which contains all constants used to simulate keyboard operations
 from import Keys

 driver = ()
 ("http://127.0.0.1:5500/webstorm/")

 #Use variables to store the obtained elements, concise subsequent code
 username = driver.find_element(, "username")
 username.send_keys("root")
 sleep(1)
 #Simulate ctrl+a
 username.send_keys(, 'A')
 sleep(2)
  • Keys.BACK_SPACE: Backspace
  • : Tab key
  • :Enter key
  • : Shift key
  • :Ctrl key
  • :Alt key
  • :Esc
  • Keys.PAGE_DOWN: Page Down key
  • Keys.PAGE_UP: Page Up key
  • : End key
  • : Home button
  • :Left arrow key
  • : Up arrow key
  • : Right arrow key
  • : Down arrow key
  • :Delete key
  • : Insert key
  • Keys.F1arriveKeys.F12:F1 to F12 function keys
  • : Meta key (equivalent to Command key or Windows key on some keyboards)
  • Keys.ARROW_DOWN、Keys.ARROW_UP、Keys.ARROW_LEFT、Keys.ARROW_RIGHT: Another representation of arrow keys

Get verification information

driver = ()
 ("")
 print('Before login=============================')
 # Print the current page title
 title =
 print(title)
 # Print the current page URL
 now_url = driver.current_url
 print(now_url)

There is anothertextAttributes to get text information between tag pairs

Set elements waiting

When the browser loads the page, the elements on the page may not be loaded at the same time, so the element needs to be set to wait

Explicitly wait
Used before,WebdriverWait for a certain condition to continue execution, otherwise a timeout exception will be thrown when the maximum time is reached.
WebDriverWaitClass is fromWebDirverThe waiting method provided. During the setting time, the current page element is detected every once in a while. If the setting time is not detected, an exception will be thrown.

WebDriverWait(driver, timeout, poll_frequency=0.5, ignored_exceptions=None)
  • driver: Browser driver
  • timeout: Maximum timeout, default to seconds
  • poll_frequency: The interval (step) time of detection, default is 0.5S
  • ignored_exceptions: Exception information after timeout, thrown by defaultNoSuchElementExceptionabnormal

WebDriverWait()Generally byuntil()oruntil_not()Methods are used in conjunction with

until(method, message='')

Call the driver provided by this method as a parameter until the return value isTrue

until_not(method, message=’ ’)

Call the driver provided by this method as a parameter until the return value isFalse

from time import sleep
 from selenium import webdriver
 from import Keys
 from import By
 from import WebDriverWait
 from import expected_conditions as EC
  
 driver = ()
 ("")
 #Wait until the element appears, wait for up to 5 seconds, check once every 0.5 seconds
 The element with #ID kw is the Baidu search box
 The #until method tells WebDriverWait to wait for which condition is true. It will constantly check the incoming condition until the condition is true or the maximum waiting time is reached. Here is to check whether the element exists.
 element = WebDriverWait(driver, 5, 0.5).until(EC.presence_of_element_located((, "kw")))
 element.send_keys('selenium')
 element.send_keys()
 sleep(3)

sleep()Forced waiting will cause the program to be suspended for a period of time. If the code volume is large, multiple forced waiting will affect the overall running speed.

Implicit waiting
usedriver.implicitly_wait(seconds)Method to set the implicit waiting time
secondsIt is the number of seconds that WebDriver wants to wait
Used to set the default timeout for all search elements operations throughout the WebDriver lifecycle. When WebDriver executesfindElementorfindElementsWhen a method, if the element on the page has not yet been loaded, WebDriver will wait for the specified time until the element appears or timeouts

Implicit waiting is global. Once set, all element search operations will take effect.. This means that no matter how many elements you look up in your code, WebDriver will wait according to the implicit waiting time you set

Multi-form and window switching

If the table unit is inside an iframe or frame, you need to switch to that iframe or frame first before you can interact with the elements inside it. Can be passedswitch_to.frame()Method implementation

driver = ()
 ("https://email./")
  
  #Targeting form frame
 fr = driver.find_element(By.TAG_NAME,'iframe')
 # Switch to form
 driver.switch_to.frame(fr)
 # Locate the account input box and enter
 usr_email = driver.find_element(,'email')
 usr_email.send_keys('8888888888')
 sleep(2)
# Get the current window handle
 current_window_handle = driver.current_window_handle
 # Get all window handles
 window_handles = driver.window_handles
 # Use index to select the window, here is the first window
 driver.switch_to.window(window_handles[0])
 #You can also use the window name
 driver.switch_to_window("windowName")

Page element attribute removal

For example, hyperlinktargetThe attribute is_blank, a new page will be opened. If you don't want a new window to pop up, you can delete this property

driver = ()
 ("https:///")

 delete = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.LINK_TEXT, "School Cloud")))
 #Use JavaScript to delete the target attribute of this element
 driver.execute_script("arguments[0].removeAttribute('target')", delete)
 #The page opens in this window
 ()
 sleep(1)

Pull down scrollbar

#Scroll to the bottom of the page
 driver.execute_script("(0, );")
 #Scroll to the top of the page
 driver.execute_script("(0, 0);")
 #Scroll down 500 pixels
 driver.execute_script("(0, 500);")
 #Scroll up 200 pixels
 driver.execute_script("(200, 0);")

 #The first parameter controls left and right, positive value goes to right, negative value goes to left
 #The second parameter controls up and down, positive value down, negative value up
 driver.execute_script("(100, -100)")

 from import ActionChains, Keys
 ActionChains().send_keys(Keys.ARROW_DOWN).send_keys(Keys.ARROW_DOWN).perform()
 #Perform 5 scrolling down
 i = 5
 for _ in range(i):
     actions.send_keys(Keys.ARROW_DOWN).perform()

How to handle the drop-down box

from import Select

 select=driver.find_element()# Get the select element
 Select(select).Method()
  • select_by_index(): Positioning through index
  • select_by_value(): Positioning by value value
  • select_by_visible_text():Positioning by text value
  • deselect_all():Cancel all options
  • deselect_by_{index|value|visible_text}():Cancel the corresponding XX option

Warning window processing

  • alert(message)Method is used to display a warning box with a specified message and an OK button.

  • confirm(message)Method is used to display a dialog box with a specified message and OK and cancel buttons. If the user clicks the OK button,confirm()returntrue. If you click the Cancel button,confirm()returnfalse

  • prompt(text,defaultText)Methods are used to display dialog boxes that prompt the user to enter. If the user clicks the Cancel button in the prompt box, then returnnull. If the user clicks the confirm button, return the text currently displayed in the input field

  • : Get the text value of the prompt

  • (): Click the "Confirm" button

  • (): Click "Cancel" or fork out the dialog box

  • alertObject.send_keys(message): Enter text, only for the propt method

driver = ()
 url = "http://127.0.0.1:5500/webstorm/"
 (url)
  
 try:
     # alert prompt box
     button = driver.find_element(, "alertButton")
     ()
     # Returns the object representing the warning box
     alertObject = driver.switch_to.alert
     ()# Click the confirm button
     sleep(1)
  
     driver.find_element(, "alertButton").click()
     sleep(1)
     ()# Click the Cancel button
 except:
     print("try1error")
  
 try:
     # confirm prompt box
     button = WebDriverWait(driver, 10).until(EC.presence_of_element_located((, "confirmButton")))
     ()
     confirmObject = driver.switch_to.alert
     print("confirm prompt box information:" + ) # Print prompt information
  
     ()
     # According to the front-end js code logic, a prompt box will pop up when clicking the OK button, so click OK again
     ()
     sleep(1)
  
     ()
     sleep(1)
     ()
     ()
     #I can't stand it anymore. Damn it's missing a confirmation test for a long time, and there is no error. If I don't write a try to catch the exception, I don't know where to find the error.
  
 except:
     print("try2error")
  
 try:
     #prompt prompt box
     button = WebDriverWait(driver, 10).until(EC.presence_of_element_located((, "promptButton")))
     ()
     promptObject = driver.switch_to.alert
     ()
     ()# Two confirmations are required
     sleep(1)
  
     ()
     ()
     ()# Confirm that no value is entered
     sleep(1)
  
  
     ()
     promptObject.send_keys("Test")
     ()
     # Pay attention to the order of the statements. If you close it twice, you cannot get the value.
     print("prompt prompt box information:" + )
     sleep(1)
     ()
 except:
     print("try3error")
 Finally:
     sleep(1)
     ()

File upload

<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="content-type" content="text/html;charset=utf- 8" />

    <title>upload_file</title>
    <link href="/bootstrap/3.3.0/css/. css" rel="stylesheet" />
</head>

<body>
    <div class="row-fluid">
        <div class="span6 well">
            <h3>upload_file</h3> <input type="file" name="file" />
        </div>
    </div>
</body>

<script src="/bootstrap/3.3.0/css/ s"></script>
</html>

For passinginputThe upload function implemented by the tag can be regarded as an input box, which can be used bysend_keys()Specify the local file path to implement file upload

upload = WebDriverWait(driver, 5, 0.5).until(EC.presence_of_element_located((, "file")))  
upload.send_keys(r"D:/software/OCR/Umi-OCR/asset/icon/")

Operation cookies

("")
  
 # Add session information to the name and value of the cookie
 driver.add_cookie({ 'name':'key1111111', 'value':'value222222' })
 all_cookie = driver.get_cookies()
 # print cookie information
 for cookie in all_cookie:
     # Replace %s respectively
     print("cookie Name:%s -> cookie Value:%s" % (cookie['name'], cookie['value']))
  
 # Delete cookies
 driver.delete_cookie('key111111')
 all_cookie = driver.get_cookies()
 print()
 for cookie in all_cookie:
     # Replace %s respectively
     print("cookie Name:%s -> cookie Value:%s" % (cookie['name'], cookie['value']))

There are also deleted cookiesdelete_delete_all_cookies

Window screenshot

('')
 driver.find_element(,'kw').send_keys('selenium')
 driver.find_element(,'su').click()
 sleep(1)
 # Snaps the current window and specify the location where the screenshot image is saved
 driver.get_screenshot_as_file("C:/")

Options

from import Options

 o=Options()
 o.add_argument('--headless')#No interface browsing
 c=(chrome_options=o)
o.set_headless() #Set start without interface
 o.add_argument('--window-size=600,600') #Set window size
 o.add_argument('--incognito') #Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Colorful Color� 
 o.add_argument('user-agent="XXXX"') #Add request header
 o.add_argument("--proxy-server=http://200.130.123.43:3456")#Proxy Server Access
 o.add_experimental_option('excludeSwitches', ['enable-automation'])#Developer Mode
 o.add_experimental_option("prefs",{"profile.managed_default_content_settings.images": 2})#Prevent image loading
 o.add_experimental_option('prefs',
 {'profile.default_content_setting_values':{'notifications':2}}) #Disable browser popups
 o.add_argument('blink-settings=imagesEnabled=false') #Prevent image loading
 o.add_argument('lang=zh_CN.UTF-8') #Set the default encoding to utf-8
 o.add_extension(create_proxyauth_extension(
            proxy_host='host',
            proxy_port='port',
            proxy_username="username",
            proxy_password="password"
        ))# Set up an agent with account password
 o.add_argument('--disable-gpu') # This property can avoid some bugs in Google
 o.add_argument('--disable-javascript') # Disable javascript
 o.add_argument('--hide-scrollbars') # Hide scrollbars

EC judgment

from  import expected_conditions as EC
  1. EC.title_contains(title)：
    • Function: Determine whether the page title contains the given string
WebDriverWait(driver, 10).until(EC.title_contains("Python"))
  1. EC.presence_of_element_located(locator)：
    • Function: Determine whether an element is loaded into the DOM tree; the element is not necessarily visible
element = WebDriverWait(driver, 10).until(EC.presence_of_element_located((, "element_id")))
  1. EC.url_contains(url_substring)：
    • Function: Determine whether the current URL contains the given string
WebDriverWait(driver, 10).until(EC.url_contains(""))
  1. EC.url_matches(url)：
    • Function: Exactly match URL
WebDriverWait(driver, 10).until(EC.url_matches(""))
  1. EC.url_to_be(url)：
    • Function: Exactly match the current URL
WebDriverWait(driver, 10).until(EC.url_to_be(""))
  1. EC.url_changes(original_url)：
    • Function: Check if the URL has changed
original_url = driver.current_url
WebDriverWait(driver, 10).until(EC.url_changes(original_url))
  1. EC.visibility_of_element_located(locator)：
    • Function: determine whether an element is visible. The element must be non-hidden.
WebDriverWait(driver, 10).until(EC.visibility_of_element_located((, "element_id")))
  1. EC.visibility_of(element)：
    • Function: determine whether the passed element is visible
element = driver.find_element(, "element_id")
WebDriverWait(driver, 10).until(EC.visibility_of(element))
  1. EC.presence_of_all_elements_located(locator)：
    • Function: Determine whether at least one element exists in the DOM tree
elements = WebDriverWait(driver, 10).until(EC.presence_of_all_elements_located((By.CLASS_NAME, "class_name")))
  1. EC.text_to_be_present_in_element(locator, text)：
    • Function: Determine whether the text in the element contains the expected string

WebDriverWait(driver, 10).until(EC.text_to_be_present_in_element((, "element_id"), "expected text"))

11. `EC.text_to_be_present_in_element_value(locator, value)`:
     - Function: determine whether the value attribute of the element contains the expected string
         ```python
  WebDriverWait(driver, 10).until(EC.text_to_be_present_in_element_value((, "input_id"), "expected value"))
         ```

 12. `EC.frame_to_be_available_and_switch_to_it(locator)`:
     - Function: determine whether the frame can be switched in
         ```python
 WebDriverWait(driver, 10).until(EC.frame_to_be_available_and_switch_to_it((, "frame_id")))
  1. EC.invisibility_of_element_located(locator)：
    • Function: Determine whether an element does not exist in the DOM tree or is not visible

WebDriverWait(driver, 10).until(EC.invisibility_of_element_located((, "element_id")))

14. `EC.element_to_be_clickable(locator)`:
     - Function: determine whether an element is visible and clickable
         ```python
 element = WebDriverWait(driver, 10).until(EC.element_to_be_clickable((, "element_id")))
  1. EC.staleness_of(element)：
    • Function: Wait for an element to be removed from the DOM tree

WebDriverWait(driver, 10).until(EC.staleness_of(driver.find_element(, "element_id")))

16. `EC.element_to_be_selected(element)`:
     - Function: Determine whether an element is selected, usually used for drop-down list
         ```python
 WebDriverWait(driver, 10).until(EC.element_to_be_selected(driver.find_element(, "select_id")))
  1. EC.element_located_to_be_selected(locator)：
    • Function: Determine whether the selected state of the element meets expectations

WebDriverWait(driver, 10).until(EC.element_located_to_be_selected((, "select_id")))

18. `EC.element_selection_state_to_be(element, state)`:
     - Function: determine whether the selected state of an element meets expectations
         ```python
         WebDriverWait(driver, 10).until(EC.element_selection_state_to_be(driver.find_element(, "select_id"), True))
         ```
 19. `EC.element_located_selection_state_to_be(locator, state)`:
     - Function: Determine whether the selected state of the positioned element meets expectations.
         ```python
         WebDriverWait(driver, 10).until(EC.element_located_selection_state_to_be((, "select_id"), True))
         ```
 20. `EC.alert_is_present()`:
     - **Function**: Determine whether alert exists on the page.
         ```python
 WebDriverWait(driver, 10).until(EC.alert_is_present())

unittest framework

import unittest
  
 class BasicTestCase(): # Set the basic test class name and inherit the properties of the test cases in the library
     # setUp() and tearDown() are test methods that are executed when each test case is in progress. The former is the beginning and the latter is the end.
     # Program execution process: setUp()-test1()-tearDown()---setUp()-test2()-tearDown()----
     def setUp(self): # "Start method" that will be executed by each test case
         print("setUp")
  
     def tearDown(self): # "End Method" that will be executed in each test case
         print("tearDown")
  
     def test1(self): # Set test case 1, named test+xxx, will be executed in the order of Arabic numerals after test, testdemo will be executed, and test will be executed with test
         print("test1")
  
     def test2(self): # Set test case 2
         print("test2")
  
 if __name__ == '__main__': # Set the main function of the unittest to execute
     () # Call the main function for multiple test cases

 """
 Execution results:
 setUp
 test1
 tearDown
 setUp
 test2
 tearDown
 """

Special class methodssetUpClass()，tearDownClass(), execute before and after all test cases

@classmethod # Define class methods
     def setUpClass(cls): # Override the class method of the parent class
         pass

     @classmethod # Define class methods
     def tearDownClass(cls): # Override the class method of the parent class
         pass

Define class attributes. Normal methods need to access class attributes through class names, for exampletest1()Want to getguideNeed to pass a statementDirect access to class attributes

  • If the instance does not have corresponding attributes and class attributes have them, Python will automatically access the class attributes instead
import unittest
 class BasicTestCase():
  
     @classmethod
     def setUpClass(cls):
          = 'yu' # Under the class method, define class attributes
     def test1(self): # Set test case 1
         guide = # Access class attributes by class name
         print(f"Guide from class: {guide}") # output the value of the class attribute
  
     def test2(self): # Set test case 2
         # You can also access class properties in other test cases
         guide =
         print(f"Guide from class in test2: {guide}")
  
 if __name__ == '__main__': # Set the main function of the unittest to execute
     () # Call the main function for multiple test cases

 """
 Output result:
 Guide from class: yu
 Guide from class in test2: yu
 """

In the Unittest suite, the global instance properties can besetUp,tearDownSettings in

class BasicTestCase():
     @classmethod
     def setUpClass(cls):
          = 'yu' # Under the class method, define the class attribute = 'yu'
         pass

     def setUp(self):
          = 'ba' # Under the setUp() method, define the global instance attribute = 'ba'

     def test1(self):
         guide = # 3. In this sentence, this sentence also gets guide = 'ba' because the instance defines the global instance attribute in setUp = 'ba'

 if __name__ == '__main__': # Set the main function of the unittest to execute
     ()
  • The normal method (test1) can only define the "authority" instance attribute, and the life cycle is within this method, and dependencies cannot be created.
class BasicTestCase():
     def setUp(self):
          = 'ba' # Under the setUp() method, define the "global" instance attribute = 'ba'

     def test1(self):
         guide = 'shi' # Define the "authority" instance attribute guide = 'shi' in test1
         print(guide) # The guide you got here = 'shi'

     def test2(self):
         guide =
         print(guide) # The guide obtained here = 'ba', not 'shi', which means that the life cycle of instance variables in ordinary methods is limited to "authority" and cannot depend on each other

 if __name__ == '__main__': # Set the main function of the unittest to execute
     ()
  • @('Reason for skipping')
  • @('Skip condition', 'Reason for skipping')
  • @('The condition not skipped', 'Reason for not skipped')
    The following test only executes test3, because test1 skips, test2 meets the skip condition, test3 meets the skip condition
class BasicTestCase():
  
     @('Skip because I want to skip') # Skip directly
     def test1(self):
         print('Execute test1')
  
     @(888 < 999, 'Skip because 888 is smaller than 999') # Conditional Skip
     def test2(self):
         print('Execute test2')
  
     @('You are so awesome', 'Because you are so awesome, I won't skip it')
     def test3(self):
         print('Execute test3')
  
 if __name__ == '__main__': # Set the main function to execute unittest
     ()

The import of conditional skip parameters must be defined under the class
because@()The execution priority of statements is greater than all defs, that is, whether setUp(), setUpClass() or test2() are executed after it, so the definition must be under the class

class BasicTestCase():
      number = '888'
      @(number < '999', 'Skip because number is smaller than 999')
      def test2(self): # will not be executed because 888 meets the skipped condition
          print('Execute test2')

Methods for skipping parameter linkage among test cases
Statement encoding + class attribute variables -> class attribute variables are usually made with lists, dictionaries, etc., which are convenient to solve multi-condition dependencies

class BasicTestCase():
     judge = {'first': 0}

     def test2(self):
         print('Execute test2')
         ['first'] = 888 # Change the value of the variable to depend on for the next test

     def test3(self):
         if ['first'] == 888: # Set the determination conditions to see if you need to skip it
             return # If the condition is met, return will be directly terminated. No subsequent statements under this test will be executed
         # print('Execute test3') # This sentence in this code will not be executed if it is added or not added. The test passes but the execution statement is not executed because according to the dependency conditions test3 has ended

 if __name__ == '__main__': # Set the main function of the unittest to execute
     ()

assertion

  1. assertEqual(a, b)andassertNotEqual(a, b):examineaWhether it is equal to or not equal tob
  2. assertTrue(expr)andassertFalse(expr):exprWhether it is true or false
  3. assertIn(member, container)andassertNotIn(member, container):examinememberWhether it is or notcontainermiddle
  4. assertIsNone(expr)andassertIsNotNone(expr):examineexprWhether it is or notNone

Data-driven test ddt

When you encounter tests with the same execution steps and only need to change the entry parameters, using ddt can simplify the code.

import unittest
 import ddt
  
 # Code not used for data-driven tests:
 class BasicTestCase():
     def test1(self):
         num1 = 666 # Use static values
         print('number from test1:', num1)
  
     def test2(self):
         num2 = 777 # Use static values
         print('number from test2:', num2)
  
     def test3(self):
         num3 = 888 # Use static values
         print('number from test3:', num3)
  
  
 # Use data-driven test code, the execution effect is the same as above
 @
 class BasicTCase():
     @('666', '777', '888')
     def test(self, num):
         print('data driven number:', num)

Data-driven test for single parameter

  • Steps: Guide Package—> Settings@ddtDecorator—>Write Parameters—>Model Parameters Pass—>Call
@ # Set @ddt decorator
 class BasicTestCase():
     @('666', '777', '888') # Set the @data decorator and write the passed parameters into brackets
     def test(self, num): # test entry sets the formal parameters
         print('data driven number:', num)
 # The program will perform three tests, with the entry parameters being 666, 777, and 888 respectively.

Multi-parameter data-driven test (one test parameter contains multiple elements)

  • Guide Package—> Settings@ddtDecorators—> Settings@unpackUnpacking—>Write parameters—>Model parameters pass—>Call
@
 class BasicTestCase():
     @(['Zhang San', '18'], ['Li Si', '19']) # Set the @data decorator and write the same set of parameters into brackets[]
     @ # Set the @unpack decorator sequence unpacking, if the unpack is missing, it is equivalent to name = ['Zhang San', '18']
     def test(self, name, age):
         print('name:', name, 'age:', age)
 # The program will perform two tests, with the entry parameters ['Zhang San', '18'], ['Li Si', '19']

File driver

# Single parameter txt file
 # Create a new num file, txt format, store 777, 888, 999 by line
 # num file content (parameter list):
 # 777
 # 888
 #999
 # Edit the function to read the data file
 # Remember to set the encoding method when reading files, otherwise the Chinese characters you read may appear garbled!  !  !  !  !  !
 def read_num():
     lis = [] # Store data in a list to pass into the @data area
     with open('num', 'r', encoding='utf-8') as file: # Open the file 'num' in the way of read-only 'r' and encoding as 'utf-8', and name it file
         for line in (): # Loop to read each line of the file by line
             (('\n')) # Add this line of data to the list element after reading one line, remember to delete the '\n' line break character of the element!  !  !
         return lis # Return the list as the content received by @data
 @ddt
 class BasicTestCase():
     @data(*read_num()) # The entry parameter is set to read_num(), because the return value is a list, so adding * means reading the list element one by one
     def test(self, num):
         print('data driven number:', num)
# Multi-parameter txt file
 # dict file content (parameter list) (storage by line):
 # Zhang San, 18
 # Li Si, 19
 # Wang Wu, 20
 def read_dict():
     lis = [] # Store data in a list to pass into the @data area
     with open('dict', 'r', encoding='utf-8') as file: # Open the file 'num' in the way of read-only 'r' and encoding method 'utf-8', and name it file
         for line in (): # Loop to read each line of the file by line
             (('\n').split(',')) # After deleting the newline, the list is ['Zhang San, 18', 'Li Si, 19', 'Wang Wu, 20']
             # According to, after segmentation, the list is [['Zhang San', '18'], ['Li Si', '19'], ['Wang Wu', '20']]
         return lis # Return the list as the content received by @data
 @ddt
 class BasicTestCase():
     @data(*read_dict()) # Add * means to read list elements one by one, variable parameters in Python, * means to read list elements one by one, the list is [['Zhang San', '18'], ['Li Si', '19'], ['Wang Wu', '20']]
     @unpack # Unpack through unpack and pass parameters one by one. If this sentence is missing, it will pass ['Zhang San', '18'] to name, resulting in the age being empty
     def test(self, name, age): # Set the formal parameters of two received parameters
         print('name:', name, 'age:', age)

csv file

"""
 1, John Doe,john@
 2, Jane Smith,jane@
 3,Bob Johnson,bob@
 """
 import csv
  
 # Define the path to the CSV file
 csv_file_path = ''
  
 # Open CSV file for reading
 with open(csv_file_path, mode='r', newline='') as csv_file:
	 data=[]
     # Create a CSV reader
     csv_reader = (csv_file) # Use DictReader to read data in dictionary form
     # Read each line and print
     for row in csv_reader:
         print(row) # print the contents of each line
		 (row)
         # If you need to access a specific column, you can use the column name
         print(f"ID: {row['id']}, Name: {row['name']}, Email: {row['email']}")

Performance Testing

Term definition

  1. Software performance is a kind of softwareNon-functional features, it is not about whether the software can complete a specific function, but about the timeliness, stability, reliability, processing capabilities, etc. displayed when completing the function.
  2. Performance testing is to simulate various normal, peak and abnormal load conditions through automated testing tools.Performance metricsPerform a test.
  3. Response time is divided into presentation time andServer response timeTwo parts.
  4. Pay attention to the response time of a business, and you can define the business asTransactions. Configure the test method to the system under testSoftware and hardware environmentto understand the degree of impact of various environments on system performance, and to find the optimal allocation principle of various resources in the system

Virtual User Generator

Each Vuser script contains at least onevuser_init,One or moreAction,onevuser_end
![[Pasted image ]]

Run multiple iterationsVuserWhen scripting, onlyActionSome scripts can be executed repeatedly

![[Pasted image ]]

VuGen recording principle
![[Pasted image ]]

VuGen Function

Meeting point
lr_rendezvousMake sure all virtual users arrive at this sequential point before performing the next operation. This can be used to simulate scenarios where multiple users operate the system simultaneously, such as logging in at the same time, submitting orders at the same time, etc.

Checkpoint

  • web_reg_find: Check the text
  • web_image_check: Check the picture

Parameter association

  • lr_eval_string("{param_name}"): parse the parameter name and return its value
  • lr_save_string("value", "param_name"):Save string value into parameter
  • lr_save_int(int_value, "param_name")
  • lr_save_double(double_value, "param_name")
  • lr_save_substring("Hello, World!", 7, 5, "greeting"): Extract 5 characters from 7 bits: World, save to greeting parameter
  • atoi(lr_eval_string("variable")): Convert string to integer
  • atof(lr_eval_string("param_name")): Convert a string to a floating point number

JMeter

Running in non-GUI mode
cd into the bin directory and enter:
jmeter -n -t jmx script path -l log log path -e -o test report path

Scope
Sampler: does not interact with other components and has no scope
Logic controller: only works on samplers and logic controllers in its child nodes
Other components:

  • If it is a child node of a sampler, the component only works on its parent node
  • If its parent node is not a sampler, its scope is all other descendant nodes under the parent node of the component

Interface testing

Term definition

  1. Interface testing concept: it is to test the system componentsinterfacea test method.
  2. The focus of interface testing: checking the exchange of data, the correctness of data transmission, andinterfacelogical dependencies between them.
  3. The significance of interface testing:softwareWhile development, parallel testing is implemented, reducing the depth of page-level testing and shortening the testing cycle of the entire project.
  4. What problems can be found in interface testing: you can find many bugs that cannot be found on the page, check the system's exception handling capabilities, check the system's security, stability, and modify itRequest parameters, break through the front-end page input limit.
1. Interface: refers to the interaction points between the system or components, through which data interaction can be realized (the channel for data transmission interaction)
 2. Interface testing: Test the interface between the system or components to verify the correctness of the passed data and the correctness of the logical dependencies.

Get and set variables at different levels

If variables with the same name exist, Postman parses them in order of priority. Priority from high to low is: script variable, collection variable, environment variable and global variable

Local variables are also called request-level variables and are only valid for the current request

  • ("Variable Name"): Check whether the specified variable exists, returnboolean
  • ("Variable Name"): Get the variable, if the variable does not exist, it will returnundefined
  • ("Variable Name", variable value of any type): Set the value of the specified variable
  • ("String"): Replace the placeholder of all dynamic variables in the given string
// Check whether the variables exist.
 if (("endpoint")) {
 // Get the value of the variable endpoint
 var endpointValue = ("endpoint");
 ("Endpoint: " + endpointValue);
 // Use variable values ​​to build a complete URL
 var url = ("/api/{{endpoint}}");
 ("URL: " + url);
 // Set a new variable completeUrl
 ("completeUrl", url);
 }
 else {
 ("The variable endpoint does not exist");
 }

Collection variables are used throughout the collection and are used to share data between requests within the same collection.

  • ("Variable Name")
  • ("Variable Name")
  • ("Variable Name", variable value of any type)
  • ("Variable Name")
  • ():Clear all collection variables
  • ("Variable Name")

Environment variables are valid throughout the environment and can be used across multiple requests

  • ("Variable Name"): Check whether the specified environment variable exists
  • ("Variable Name"): Get the value of the specified environment variable
  • ("Variable Name", variable value of any type): Set the value of the specified environment variable
  • ("Variable Name"): Delete the specified environment variable
  • ()
  • ("Variable Name")

Global variables are valid throughout Postman applications and can be used across multiple environments and requests

  • ("Variable Name"): Check whether the specified global variable exists
  • ("Variable Name"): Get the value of the specified global variable
  • ("Variable Name", variable value of any type): Set the value of the specified global variable
  • ("Variable Name"): Delete the specified global variable
  • ()
  • ("Variable Name")

Iterative variables are special variables used to store and use data in Data-Driven Testing. Iterative variables read data from external data sources (such as CSV files or JSON files) each time the collection is run, and use this data in each iteration

  • .has("variable name")
  • .get("variable name")
  • ("Variable Name")
  • .toJSON("variable name"): Convert the iterationData object to JSON format

Operation request data

  • :Current request URL
  • :The headers currently requested
  • : The method of the current request
  • : The currently requested Body
= "/api/new-endpoint";
  = "PUT";
  = { mode: "raw", raw: ({ key: "new-value" }) };
 //Add a new header
 ({ key: "Authorization", value: "Bearer your-token" });
 //Delete the header with the specified name
 ("Authorization");

Operation response data

  • : Get the HTTP status code of the response
  • : Get the HTTP status information of the response
  • : Get a collection of response headers to access specific header information
  • : Get the number of milliseconds it takes for the server to respond to the request
  • : Get the response body size, bytes in units
  • ():Convert the response body to a string and return
  • ():Convert the response body to json to return

assertion

Synchronous and asynchronous testing

//Test to check whether the response is valid
 ("response should be OK to process", function () {
   ;
   ('');
   ('error');
 });

 // Check whether the response status code is 200 after 1.5 seconds
 ('async test', function (done) {
   setTimeout(() => {
     ().(200);
     done();
   }, 1500);
 });

Output variable value or variable type

(("name"));
 (().name);
 (typeof ().id);
 if (().id) {
   ("id was found!");
 } else {
   ("no id...");
   //do something else
 }// For loop reads for (condition) { statement;}

Status code detection

//Way
 ("Status code is 200", function () {
   (200);
 });
 //Expect method
 ("Status code is 200", () => {
   ().(200);
 });

Multiple assertions as the result of a single test

("The response has all properties", () => {
     //parse the response JSON and test three properties
     const responseJson = ();
     ().('vip');
     ().('string');//Check whether it is of string type
     ().(1);//Check whether it is an array of length 1
 });

Different types of return result analysis

//Get the returned json data
 const responseJson = ();
 //Convert number to JSON format
 ()
 //Convert json data to array
 (jsondata)
 //Get xml data
 const responseJson = xml2Json(());
 //Get csv data
 const parse = require('csv-parse/lib/sync');
 const responseJson = parse(());
 //Get html data
 const $ = (());
 //output the html for testing
 ($.html());

Testing a specific value in response body reponseBody

("Person is Jane", () => {
   const responseJson = ();
   ().("Jane");
   ().(twenty three);
 });//Get the response body ()

Test response headers

//Test whether the response header exists
 ("Content-Type header is present", () => {
   ("Content-Type");
 });
 //Test the specific value of the response header
 ("Content-Type header is application/json", () => {
   (('Content-Type')).('application/json');
 });
 //Get the response header "Server" data
 ("Server")

Functional testing

Test classification
Divided by code visibility:

  • Black box test
    • Source code is not visible
    • UI functions are visible
  • Grey box testing
    • Some source codes are visible
    • UI functionality is not visible
  • White box test
    • Source code is visible
    • UI functionality is not visible

Equivalent classification method

Among all test data, data sets with some common characteristics are divided
Classification:

  • Effective equivalent category: Data collection that meets the needs
  • Invalid equivalent: data set that does not meet the needs
    Applicable scenarios
    A lot of data test input is required, but it cannot be exhaustive
  • Input box
  • Drop-down list
  • Single-choice/checkbox

Example:
need:

  1. Area code: empty or three digits
  2. Prefix code: three digits starting with non-"0" or "1"
  3. Suffix code: four digits

Define valid and invalid equivalents

parameter illustrate efficient Valid data invalid Invalid data
Area Code length Empty, 3 digits 1. Empty
2. 123		 Non-3 12
Prefix code length 3 234 Non-3 23
Suffix code length 4 1234 Non-4 123
Area Code type number / Non-digital 12A
Prefix code type number / Non-digital 23A
Suffix code type number / Non-digital 123A
Area Code rule / / / /
Prefix code rule Non-0, non-starting / 1. Starting with 0
2. 1		 1. 012
2. 123
Suffix code rule / / / /

Two valid data, eight invalid data

Boundary value analysis method

Select==or>or<The boundary value is used as test data

  • Up point: Point on the boundary (equal to)
  • To the point: the point closest to the upper point (just greater than/just less than)
  • Inner point: points in range (data in interval range)
<Previous Next>