Видео

seems to be global problem...

will need more details and specific steps for this

@@RaghavPal yes,I need please kindly assist me I was stuck with my work please

Aparna The issue you're encountering with the statement `cy.get('#login-error .message').should(have.text,'Invalid password')` might be related to the pseudo-element `::before`. When using Cypress selectors, you can't directly target pseudo-elements like `::before` or `::after`. To work around this, consider the following approach: 1. Target the Parent Element: - Instead of directly selecting the pseudo-element, target the parent element (in this case, the `<div class="message">`). - Then, use Cypress commands to verify the text content. 2. Example: ```javascript cy.get('#login-error .message') .should('be.visible') // Ensure the element is visible .invoke('text') // Get the text content .should('eq', 'Invalid password'); // Verify the expected text ``` 3. Explanation: - The above code first ensures that the `.message` element is visible. - It then retrieves the text content using `.invoke('text')`. - Finally, it asserts that the text matches `'Invalid password'`. Remember that pseudo-elements like `::before` are not directly accessible via Cypress selectors, so focusing on the actual DOM elements is the key. For more information on handling custom assertions and working with Cypress, you can refer to the [official documentation] learn.cypress.io/real-world-examples/login-errors -

@@RaghavPal thank you

Jagadeesh Playwright supports multiple languages, and the choice depends on your familiarity and project requirements. Here are the recommendations: 1. JavaScript and TypeScript: - Playwright for Node.js has its own test runner with parallelization, screenshot assertions, and more. - TypeScript is recommended for its strong type system and better tooling support 2. Python: - Use the Playwright Pytest plugin for end-to-end tests. It provides context isolation and runs on multiple browser configurations 3. Java: - Choose a testing framework like JUnit or TestNG based on your project needs 4. .NET: - Playwright for .NET includes NUnit and MSTest base classes for writing end-to-end tests Ultimately, pick the language you're most comfortable with and project needs -

Playwright is good choice for automating React applications. Here's why: 1. Targeting React Components: - With Playwright, you can easily target React components to test modular UIs - It ensures test reliability and speed, allowing developers to focus on building rather than debugging. 2. Features of Playwright: - Cross-Browser Compatibility: Playwright works with modern rendering engines (Firefox, WebKit, Chromium). - Headless and GUI Modes: Launch browsers in GUI mode for development/debugging or headless mode for faster testing. - Cross-Language Support: Access the Playwright API from JavaScript, TypeScript, Python, .NET, and Java. - Mobile Web Evaluation: Supports Chrome for Android and Mobile Safari native emulation. - CI Integration: Easily integrate with CI environments for continuous testing. - Playback and Codegen Recording: Create test scripts by recording interactions with the browser 3. Unified Testing Strategy: - Playwright helps create a unified testing strategy across different levels, including end-to-end testing for React applications Feel free to explore Playwright for your React projects-it's a powerful tool for automating web interactions Do a POC before finalising the tool -

In this playlist i focussed on the setup part for both android and ios which is most tricky and time consuming in mobile testing with appium. I have an earlier Appium playlist where you can find the code and framework. Pls check here - automationstepbystep.com/

@@RaghavPal Okay thankyou 🙏 Are you going to add move video in this playlist. If yes then can you please cover the any app like fb, insta etc... where we use login functionality

Elena Try using the path with single forward slash '/' npx playwright test ./tests/my_first_test.spec.ts Here are a few potential solutions based on the information available: 1. Test Discovery Issue: - The error message "No tests found" suggests that Playwright is unable to discover any test files. - Make sure that your test files are correctly located and named. Ensure that they follow the expected naming conventions (e.g., ending with `.spec.ts`). - Verify that your test files contain valid test cases using the Playwright test framework. 2. Configuration File Issue: - Check if you have a configuration file (usually named `playwright.config.js` or `playwright.config.ts`) in your project. - Ensure that the configuration file specifies the correct test directory and test file patterns. - If you're using a custom configuration, review it to make sure it's correctly set up. 3. Test Execution Syntax: - When running tests with `npx playwright test`, you can specify test files using regular expressions. - Double-check that the path you're providing to `npx playwright test` matches the actual location of your test files. - If your test file path contains special characters (e.g., `$`, `*`), escape them properly. 4. Parallel Execution Issues: - If you're running tests in parallel, ensure that there are no conflicts between test files. - Sometimes parallel execution can cause issues with shared resources (e.g., login sessions). - Consider running tests sequentially (`--workers 1`) to see if the problem persists. 5. Azure DevOps Pipeline Specifics: - In your Azure DevOps Pipeline configuration (`azure-pipelines.yml`), you might need to adjust settings related to Node.js version, browsers, and parallel execution. - Review the pipeline steps and verify that they match your local setup. 6. Unique Tags for Tests: - If you want to exclude specific tests from execution, consider adding unique tags to describe blocks in your test files. - Use the `--grep` and `--grep-invert` CLI parameters to selectively run or exclude tests based on these tags². Remember that debugging issues like this often involves trial and error. Start by checking the basics (file paths, configuration, etc.), and gradually narrow down the problem

Ajit It must be hosted runner as i did not setup any infrastructure at my end

Navneet To set a common Bearer Token and Base URL for a single collection in Postman, you have a few options: 1. Collection Variables: - Create a collection variable for the Bearer Token and Base URL. - In your collection, go to the Variables tab. - Define the following variables: - `tokenBaseURL`: Set this to the base URL for your authentication service. - `authData`: If your auth service requires specific data, add it here as a JSON object. - Now, your requests within the collection can reference these variables. 2. Pre-request Script: - You can use a pre-request script at the collection level to set environment variables dynamically. - Here's an example of how to set the Bearer Token using a script: ```javascript pm.sendRequest({ url: 'YourURL', method: 'POST', header: { 'content-type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ // YOUR PARAM TO CREATE THE TOKEN IF NEEDED }) } }, (err, res) => { pm.collectionVariables.set('TOKEN', res.json().accessToken); }); ``` 3. Environment Variables: - Create a new environment or use an existing one. - Add environment variables for the Bearer Token and Base URL. - Set the values accordingly. Remember to choose the approach that best fits your project requirements and workflow -

Navneet To set a common Bearer Token and Base URL for a single collection in Postman, you have a few options: 1. Collection Variables: - Create a collection variable for the Bearer Token and Base URL. - In your collection, go to the Variables tab. - Define the following variables: - `tokenBaseURL`: Set this to the base URL for your authentication service. - `authData`: If your auth service requires specific data, add it here as a JSON object. - Now, your requests within the collection can reference these variables. 2. Pre-request Script: - You can use a pre-request script at the collection level to set environment variables dynamically. - Here's an example of how to set the Bearer Token using a script: ```javascript pm.sendRequest({ url: 'YourURL', method: 'POST', header: { 'content-type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ // YOUR PARAM TO CREATE THE TOKEN IF NEEDED }) } }, (err, res) => { pm.collectionVariables.set('TOKEN', res.json().accessToken); }); ``` 3. Environment Variables: - Create a new environment or use an existing one. - Add environment variables for the Bearer Token and Base URL. - Set the values accordingly. Remember to choose the approach that best fits your project requirements and workflow -

Most probably you might have the path of chrome driver set in your path env variables

@@RaghavPal Thank you sir 😊

You're welcome

Let's troubleshoot this. 1. File Naming Convention: - Playwright Test expects test files to be suffixed with either `.spec.js` or `.test.js`. Make sure your `FirstTest.js` file follows this convention. - If it doesn't, consider renaming it to `FirstTest.spec.js` or `FirstTest.test.js`. 2. Configuration File: - Check if you have a configuration file (usually named `playwright.config.js` or similar) in your project. - Ensure that you're not calling `test.describe()` directly in the configuration file. Test descriptions should be in separate test files. - Also, avoid calling `test.describe()` in files imported by the configuration file. 3. Dependencies: - Verify that you're using the correct version of `@playwright/test`. - Sometimes having different versions of `@playwright/test` can cause issues. Ensure consistency across your dependencies. 4. Test Match Patterns: - If you're using a custom test match pattern, make sure it's correctly configured in your `playwright.config.js`. - By default, Playwright Test runs tests from files matching `(test|spec)`. -

Thanks for the kind words

Most welcome

Groovy Spock is an interesting choice for test automation, and while it's true that it has been around for a while, it still has its merits. Let's break it down: 1. What is Groovy Spock? - Groovy is a dynamic language that runs on the Java Virtual Machine (JVM). It's known for its concise syntax and seamless integration with Java libraries. - Spock is a testing framework built on top of Groovy. It combines the best of behavior-driven development (BDD) and data-driven testing. - Spock tests are written in a human-readable format, making them easy to understand and maintain. 2. Advantages of Groovy Spock: - Expressive Syntax: Spock's syntax allows you to write clear and concise test cases. It reads like natural language, which can be helpful for both developers and non-developers. - Data-Driven Testing: Spock excels at parameterized testing. You can easily define data tables and run the same test with different inputs. - Integration with Java: Since Groovy runs on the JVM, you can seamlessly use existing Java libraries and frameworks. - Mocks and Stubs: Spock provides built-in support for mocking and stubbing, making it easier to isolate components during testing. 3. Considerations: - Maturity: While Groovy Spock has been around for a while, it's also stable and battle-tested. Many companies still use it successfully. - Community: Although it might not be as hyped as some newer tools, Spock has an active community that provides support and shares best practices. - Job Market: Consider the job market in your area. If companies in your region actively use Spock, it could be a valuable skill. - Company Context: Evaluate the company's overall tech stack, development practices, and team culture. Sometimes an older technology can coexist with modern practices. 4. Final Thoughts: - Learn and Adapt: If you decide to join the company, embrace the opportunity to learn Spock. It's a valuable skill, especially if you work with legacy codebases. - Stay Curious: Keep an eye on trends and explore other testing tools. Being adaptable is essential in the tech industry. Remember that technology choices depend on context. If the company's projects align with your interests and career goals, don't dismiss it solely based on the tooling. Ultimately, your growth and learning matter most -

Holy moly, thanks alot for such extensive answer! Almost feels like chat GPT generated😅 but joking aside thank you!

You're very welcome Sansta

Here are the steps to connect your iPhone or iPad to your Mac over Wi-Fi: 1. Simulator (for testing): - If you want to test your app on a simulated iOS device, you can use Xcode's Simulator. It allows you to debug your app on various hardware configurations without immediate access to physical devices. - To add or configure simulated devices, open Xcode, go to Window > Devices and Simulators, and manage them from the Simulators tab. - Keep in mind that simulated devices don't fully replicate the performance or features of actual devices 2. Real Device (for testing and development): - To connect a real iOS device wirelessly, follow these steps: - Connect your device to your Mac using a USB cable. - Open Xcode and go to Window > Devices and Simulators. - In the Devices tab, select your connected device. - Enable the checkbox for "Connect via network." - Now your device is paired with Xcode over Wi-Fi, and you can run your app wirelessly 3. iTunes (for syncing): - If you want to sync content wirelessly (like music, photos, or backups), you can use iTunes: - Connect your iPhone or iPad to your PC using a compatible USB charging cable. - Launch iTunes on your PC. - Click the iPhone button near the top-left of the iTunes window. - In the sidebar, click Summary. - Select the checkbox for "Sync with this [device] over Wi-Fi." - Click Apply Remember that when running apps in Simulator, some hardware-specific features might not be available. For testing specific features, always run your code on a real device -

You can't

Most welcome

Glad it helped

So nice of you Saba

Piyush When working with PDF forms in Playwright, you'll need to interact with the underlying HTML elements within the PDF viewer. Here's how you can approach this: 1. Identify the Button: - First, ensure that the "I Agree" button in the PDF form has a unique identifier (such as an `id` or `class`). - You'll need to inspect the PDF viewer using browser developer tools to find the correct selector for the button. 2. Navigate to the PDF Page: - Load the PDF using Playwright (e.g., `page.goto('example.com/my.pdf')`). - Make sure the PDF viewer is fully loaded before proceeding. 3. Locate and Click the Button: - Use Playwright's `page.locator()` to find the button element based on its selector. - Then, click the button using `.click()`. Example (assuming the button has an `id` of "agreeButton"): ```javascript const pdfUrl = 'example.com/my.pdf'; await page.goto(pdfUrl); // Wait for the PDF viewer to load (you might need to adjust the selector) await page.waitForSelector('.pdf-viewer'); // Locate and click the "I Agree" button await page.locator('#agreeButton').click(); ``` 4. Handling PDF Viewer: - Note that the PDF viewer itself might be an or a custom component. - If the PDF viewer is an , switch to it using `page.frame()` before locating the button. Remember to adapt the code above to your specific use case, considering the structure of the PDF viewer and the actual selector for the "I Agree" button. -

Raunak Handling a large JSON file with 500,000 lines can be challenging, but there are tools available to help you automatically fix errors. Here are a few options: 1. Online JSON Fixers: - [JSON Fixer Online] codebeautify.org/json-fixer : This online tool allows you to repair invalid JSON data. It can add missing quotes around keys, escape characters, commas, and more¹. - [BetterJSON] www.betterjson.com/ : Another online validator and formatter that lets you upload, validate, and format your JSON with ease⁷. - [JSONLint] jsonlint.com/ : A free online tool for validating, formatting, and beautifying JSON data⁵. 2. Visual Studio Code Extension: - If you're using Visual Studio Code, consider installing the [Fix All JSON] marketplace.visualstudio.com/items?itemName=zardoy.fix-all-json extension. It automatically fixes common JSON issues when you save your file³. 3. Manual Approach: - If you prefer a programmatic solution, you can write a script in your preferred programming language (such as Python or JavaScript) to read the large JSON file, identify errors, and correct them. - For example, you can load the JSON data, parse it, and then write it back with proper formatting. Remember that handling such a large file may require additional memory and processing power. Choose the approach that best suits your needs and resources -

@@RaghavPal Thank You So Much Sir I really appreciate your efforts how you wrote such a long comment and given so many options and explained each one of it to help your 1 viewer again Thank You Very Much.

Mahfoud ,Can try this command npx playwright codegen --comments

@@RaghavPal I get this : error: unknown option '--comments'

Try like this npx playwright codegen demo.playwright.dev/todomvc

You're welcome!

Did not get you Mahesh

Seran Here are a few steps you can follow to resolve the error: 1. Permissions Issue: - First, ensure that you have the necessary permissions to create files and directories in the location where you're running the command. - If you're in a system folder (e.g., `C:\\Program Files\ odejs`), try running the command as an administrator. Open your terminal as an administrator and then execute `npm init playwright@latest`. 2. Clean Up Existing Files: - Delete the `node_modules` folder and the `package-lock.json` file if they exist in your project directory. - Then, rerun the command: `npm init playwright@latest`. 3. Retry the Installation: - After cleaning up, try running the initialization command again: `npm init playwright@latest`. - This time, everything should be installed correctly. Remember to follow these steps, and hopefully, you'll be able to create your Playwright project successfully -

I will plan Vishal

Thanks and welcome Rakesh

You're most welcome Danu

Trapti Certainly! Let's get you started with installing and integrating Appium Studio for Eclipse. This lightweight plugin allows you to kick off your Appium testing using real devices directly from Eclipse. Here are the steps: 1. Installation of Appium Studio for Eclipse: - Prerequisites: - Ensure you have Eclipse version 4.6 or higher installed. - Sign up for a SeeTest Digital Assurance Lab account (it provides access to remote devices). - Two Installation Options: - Eclipse Marketplace: 1. Inside Eclipse, go to Help ➡️ Eclipse Marketplace. 2. Search for "Appium Studio" and click Install. 3. Agree to the User Agreement and allow Eclipse to reboot. - Install from File: 1. [Download the Appium Studio for Eclipse installation file] www.softwaretestinghelp.com/appium-studio-for-eclipse-tutorial-12/ 2. In Eclipse, navigate to Help ➡️ Install New Software.... 3. Click Add, then select the downloaded zip file. 4. Choose STAE (SeeTest Automation Eclipse), accept terms, and click Finish. 2. Connecting to Remote Mobile Devices: - Register for the SeeTest Digital Assurance Lab to access real Android and iOS devices. - Generate an access key (username, password, and project name) to connect to the lab. - Develop and execute Appium tests on these devices while monitoring in real time. --

Sure Praveen.. thanks for watching

To digitally sign an XML document, you can use the classes in the `System.Security.Cryptography.Xml` namespace. Here's a step-by-step guide using .NET: 1. Create a CspParameters object and specify the name of the key container: ```csharp CspParameters cspParams = new() { KeyContainerName = "XML_DSIG_RSA_KEY" }; ``` 2. Generate an asymmetric key using the `RSACryptoServiceProvider` class. The key is automatically saved to the key container: ```csharp RSACryptoServiceProvider rsaKey = new(cspParams); ``` 3. Load an XML file into an `XmlDocument` object (replace `"test.xml"` with your file path): ```csharp XmlDocument xmlDoc = new() { PreserveWhitespace = true }; xmlDoc.Load("test.xml"); ``` 4. Create a new `SignedXml` object and pass the `XmlDocument` to it: ```csharp SignedXml signedXml = new(xmlDoc); ``` 5. Add the signing RSA key to the `SignedXml` object: ```csharp signedXml.SigningKey = rsaKey; ``` 6. Create a `Reference` object that describes what to sign (to sign the entire document, set the `Uri` property to `""`): ```csharp Reference reference = new() { Uri = "" }; ``` 7. Add an `XmlDsigEnvelopedSignatureTransform` object to the `Reference` object: ```csharp reference.AddTransform(new XmlDsigEnvelopedSignatureTransform()); ``` 8. Add the reference to the `SignedXml` object: ```csharp signedXml.AddReference(reference); ``` 9. Compute the signature: ```csharp signedXml.ComputeSignature(); ``` 10. Get the XML representation of the signature and attach it to the document: ```csharp XmlElement signatureElement = signedXml.GetXml(); xmlDoc.DocumentElement.AppendChild(signatureElement); ``` Remember to adjust the code according to your specific requirements and environment -

Can follow these steps 1. Identification of Dynamic Value: - First, identify the value that changes dynamically in your script. In your case, the "Request Id" parameter is dynamically generated. - NeoLoad can automatically identify some dynamic values based on predefined rules or generic patterns. You can also manually identify them. - To start, run a "Check User Path" validation. If any requests fail, investigate those further-they might contain dynamic values. 2. Implementation of Correlation Logic: - Once you've identified the dynamic value (e.g., "BIRDS" in your example), implement correlation logic: - Right-click on the dynamic value and select "Flag in the responses." - NeoLoad will highlight requests and transactions containing this dynamic value. - Click on the first transaction with a checkmark. - Select the request whose response contains the required dynamic value. - Click the "Advanced" button at the bottom of the pane. - Implement the correlation logic here 3. Handling Variable Number of Request Parameters: - If you encounter "Too Many Request Parameters," follow these steps: - Correlate the request parameters using variable extractors. - Use JavaScript to construct a string with all the request parameters and store it in a variable. - Change the Post Content Type to Text in the HTTP Request. - Pass the variable into the request 4. Additional Tips: - Validate your changes thoroughly to ensure proper correlation. - Remember that manual correlation may be necessary in complex cases where automatic identification falls short

Keval it is working fine here.. please check again

@@RaghavPal have you watch on 1920*1080 screen

@@RaghavPal can you please make an video for just installing Python 3.12 wxpython Ride IDE

I will plan Keval.. for now check these steps 1. Python 3.12: - Visit the official Python website at [python.org] www.python.org/ - Download the latest version of Python 3.12.0 for Windows. - Run the installer and follow the on-screen instructions to install Python. 2. wxPython: - As of wxPython 4, Python 3 is supported. - To install wxPython, open a command prompt (CMD) and run: ``` pip install wxpython ``` - Note that pip will automatically build wxWidgets for you, but it won't install system dependencies like GTK and OpenGLu. If you encounter an error during installation, check the missing packages mentioned in the error message¹. 3. RIDE IDE (Robot Framework Integrated Development Environment): - Install Robot Framework using pip or easy_install: ``` pip install robotframework ride ``` - After installation, run the following command to launch RIDE: ``` ride.py ``` Remember to adjust the commands based on your specific system configuration -

ok

Thanks

Most welcome

great

Most welcome Shane