Video

Glad it was helpful

Most welcome Tài

I will do

@@RaghavPal thankyou so much sir Along with that please give tips and tricks of how to find locater in easy way.. Currently all your gems are either is on CZcams and other is on udemy Can you please combine java+Automation+ frame work You explanation concepts is very easy then other instructors honestly.. I watch you framework of selnium it really clear my concepts in very easy way.. Please upload at earliest if possible sir.. you are a gems and a life saver...

@@RaghavPal give best tools as well for automation, your tool esry is not available at the moment

I will plan on this

Sure.. pls check here - automationstepbystep.com/

What exactly

Let's address this step by step: 1. Eclipse Requirements: - The latest Eclipse version requires Java 11 or higher - You can download Eclipse from their official website. 2. Java 11 on macOS: - Unfortunately, macOS 10.15.7 (Catalina) does not officially support Java 11. - However, you have a few options: - Install AdoptOpenJDK: You can manually install AdoptOpenJDK 11 (an open-source distribution of Java) on your Mac. It's not officially supported, but it should work. - Upgrade macOS: Consider upgrading your macOS to a version that supports Java 11 or higher. macOS Big Sur (11.0) or later versions are compatible with Java 11. - Use Docker: If you're comfortable with containers, you can run Eclipse inside a Docker container that has Java 11 installed 3. Eclipse Collections 11.0.0: - If you're specifically interested in Eclipse Collections, version 11.0.0 was released recently - Eclipse Collections is a powerful open-source collections library for Java, compatible with standard Java collections. Remember to back up your data before making any major changes to your system. If you choose to upgrade macOS or install AdoptOpenJDK, ensure compatibility with your existing software --

Most welcome

Most welcome Harsh

Suman Let's explore the difference between installing Playwright using the npm package and using the VS Code extension: 1. Install Using npm Package: - Functionality: When you install Playwright via npm (`npm install -D @playwright/test@latest`), it adds Playwright as a development dependency to your project. - Usage: You can import Playwright in your test scripts and use it directly within your project. - Browser Binaries: You'll need to download browser binaries and their dependencies separately using `npx playwright install --with-deps`. - Project Scope: Limited to the specific project where you installed it. 2. Install Using VS Code Extension: - Functionality: The Playwright VS Code extension includes a recent copy of the `@playwright/test` npm package. - Usage: If you don't have Playwright installed via npm in your project, the extension uses its internal copy of Playwright. - Browser Binaries: The extension handles browser binaries automatically. - Project Scope: Available globally within VS Code for all projects. In summary, both methods work, but the extension simplifies setup and provides a global Playwright instance within VS Code. Choose based on your project's needs --

I generally use mac tools

@@RaghavPal Thank you for responding! I have been overdosing on your videos! Top notch!

Transitioning from system administration to cybersecurity can be a rewarding choice. Here are some considerations: 1. Growing Field: Cybersecurity is in high demand due to increasing threats and data breaches. Organizations need experts to protect their systems and data 2. Skill Set: Your sysadmin experience provides a solid foundation. Focus on learning security concepts, tools, and practices. Areas to explore include network security, ethical hacking, and incident response 3. Certifications: Obtain relevant certifications (e.g., CompTIA Security+, Certified Information Systems Security Professional (CISSP), Certified Ethical Hacker (CEH)) to enhance your credentials 4. Roles: Cybersecurity offers diverse roles: - Security Analyst: Monitor and analyze security incidents. - Penetration Tester: Ethically hack systems to find vulnerabilities - Security Engineer: Design and implement security solutions. - Incident Responder: Handle security incidents. 5. Challenges: Cybersecurity can be intense and requires continuous learning. Staying updated is crucial. 6. Salary: Salaries in cybersecurity are competitive. Experienced professionals often earn well. Remember, passion and curiosity drive success in this field. If you're interested in protecting digital assets and enjoy problem-solving, cybersecurity could be an excellent fit --

Most welcome Alexandria

Thanks a lot Rajendra.. humbled

Bella If there is some specific tool, language or platform used by your company.. you can learn the same. Else in general you can find the current popular tools, languages and platforms and learn them

Juli Let's explore the difference between Page Object Model (POM) and Page Factory in Selenium for identifying web elements: 1. Page Object Model (POM): - Design Pattern: POM creates an object repository for storing web elements. - Class Structure: Each web page is represented as a separate class file. - Advantages: - Easy Maintenance: When UI elements change, POM helps identify the specific page or screen to modify. - Code Reusability: Test code for one screen can be reused in other test cases. - Readability and Reliability: Independent Java files for each screen allow efficient code changes. - Implementation: - Define a separate Java class for each page/screen. - Include UI elements and operations specific to that page. - Use these classes to perform actions on the website under test. 2. Page Factory: - Class Provided by Selenium WebDriver: Page Factory supports Page Object Design patterns. - @FindBy Annotation: Instead of using `FindElement` or `FindElements`, Page Factory uses the `@FindBy` annotation. - Implementation: - Annotate web elements using `@FindBy`. - Initialize web elements using the `initElements` method. - Descriptive annotations make it easier to locate and declare web elements. In summary, POM focuses on organizing web elements into separate classes, while Page Factory simplifies element initialization using annotations. Both approaches enhance test case maintenance and readability. Choose the one that best suits your project needs --

Yes, you can Razan

Emre Based on what i infer from your query.. In JSON Schema, you can define the type of a schema and specify its properties. Let's break it down: 1. Data Types: - JSON Schema defines several basic data types: - String: Represents text values. - Number: Includes both integers and floating-point numbers. - Object: Represents structured data with key-value pairs. - Array: Contains an ordered list of values. - Boolean: Represents true or false. - Null: Represents the absence of a value. 2. Example Schema: Here's a simple example of a JSON Schema that defines an object with a single property: ```json { "$schema": "json-schema.org/draft-04/schema", "title": "Product", "description": "A product from Acme's catalog", "type": "object", "properties": { "id": { "description": "The unique identifier for a product", "type": "integer" } }, "required": ["id"] } ``` In this schema: - The type is set to "object." - The "id" property is of type "integer." 3. Property Constraints: - You can add constraints to properties using keywords like `minimum`, `maximum`, `pattern`, and more. - For example, you can specify a numeric range for a property or require certain properties to be present. Remember to adapt these concepts to your specific use case --

@@RaghavPal Thank you, it was very descriptive.

Pawan The error message you're encountering-`Error: browserType.launch: spawn EPERM`-indicates a permissions issue when launching Chromium. Let's explore some potential solutions: 1. Permissions Issue: - Ensure that the user running the `npx playwright test` command has the necessary permissions to execute processes. - If you're on Windows, try running the terminal as an administrator. 2. Browsers Installation: - Make sure you've installed the browsers required by Playwright. You can do this by running: ``` npx playwright install ``` - If you're using a custom installation path for browsers, set the `PLAYWRIGHT_BROWSERS_PATH` environment variable to point to the correct location. For example: ``` export PLAYWRIGHT_BROWSERS_PATH=/path/to/your/browsers ``` 3. Docker Image Version (if applicable): - If you're using Playwright within a Docker container, consider pinning your Docker image to a specific Playwright version. For example: ``` docker pull mcr.microsoft.com/playwright:v1.20.0-focal ``` 4. Use @playwright/test: - You don't need to have both `playwright` and `jest` installed. `@playwright/test` is sufficient for running Playwright tests. - Remove any unnecessary installations of `playwright` or `jest`. Remember to adapt these solutions based on your specific environment and requirements --

Thanks

ok.. let me know if you faced any issues

Great

Glad it was helpful Harsh

Ahsan, it may be down or some backend issue. You can try other options. Here are some options for creating free MySQL databases online that you can use for testing and demo purposes: 1. DB Fiddle: An online SQL database playground where you can test, debug, and share SQL snippets. It's great for experimenting with queries 2. OneCompiler's MySQL Online Editor: Write, compile, debug, run, and test MySQL queries online using OneCompiler 3. db4free.net: Create an account for free and test your applications. It's useful for ensuring your apps work after a MySQL version update and for learning new features --

also i have tried the bellow step Microsoft Windows [Version 10.0.22631.3672] (c) Microsoft Corporation. All rights reserved. E:\android\cmdline-tools\latest\bin>sdkmanager --list Error: LinkageError occurred while loading main class com.android.sdklib.tool.sdkmanager.SdkManagerCli java.lang.UnsupportedClassVersionError: com/android/sdklib/tool/sdkmanager/SdkManagerCli has been compiled by a more recent version of the Java Runtime (class file version 61.0), this version of the Java Runtime only recognizes class file versions up to 60.0 E:\android\cmdline-tools\latest\bin>

Aman It seems you're encountering a couple of issues related to the Android SDK and `sdkmanager`. Let's address them step by step: 1. 'sdkmanager' is not recognized as an internal or external command: - This error occurs when the system cannot find the `sdkmanager` executable in your system's PATH. - To fix this, you need to add the correct path to the Android SDK tools directory to your system's environment variables. - Follow these steps: - Right-click on "My Computer" (or "This PC") and select "Properties." - Click on "Advanced system settings." - In the "Advanced" tab, click on the "Environment Variables" button. - Under "System variables," find the "Path" variable and click "Edit." - Add the path to your Android SDK tools directory (usually something like `C:\Users\<your_username>\AppData\Local\Android\sdk\tools\bin`). - Make sure to separate multiple paths with semicolons. - Click "OK" to save the changes. - Open a new Command Prompt window and try running `sdkmanager --list` again. 2. Java Runtime Version Error: - The second error indicates that the `SdkManagerCli` class has been compiled with a newer version of Java than the one installed on your system. - You'll need to ensure that you have the correct Java version installed. - Follow these steps: - Make sure you have the latest JDK (Java Development Kit) installed on your system. - Set the `JAVA_HOME` environment variable to point to the JDK installation directory. - Update your system's PATH variable to include the `bin` directory of the JDK. - Restart your Command Prompt and try running `sdkmanager --list` again. Remember to replace `<your_username>` with your actual Windows username --

You're very welcome Janine

Most welcome Sunil

Most welcome Satyam

I will plan.. but will take some time. Let's get you started with Playwright and TypeScript. Here's a step-by-step guide: 1. Install Node.js and npm: Make sure you have Node.js and npm (Node Package Manager) installed on your system. 2. Create a New Project: Open your terminal or command prompt and create a new directory for your Playwright project. Navigate to that directory: ```bash mkdir my-playwright-project cd my-playwright-project ``` 3. Initialize a New Node.js Project: Run the following command to create a `package.json` file: ```bash npm init -y ``` 4. Install Playwright and TypeScript: Install Playwright and TypeScript as development dependencies: ```bash npm install playwright typescript --save-dev ``` 5. Create a TypeScript Configuration File: Create a `tsconfig.json` file in your project directory: ```bash npx tsc --init ``` 6. Write Your First Test: Create a new TypeScript file (e.g., `my-test.ts`) in your project directory. In this file, import Playwright and write your test code. For example: ```typescript import { chromium, Browser, Page } from 'playwright'; describe('My First Playwright Test', () => { let browser: Browser; let page: Page; beforeAll(async () => { browser = await chromium.launch(); page = await browser.newPage(); }); afterAll(async () => { await browser.close(); }); it('should navigate to a website and assert title', async () => { await page.goto('example.com'); const title = await page.title(); expect(title).toBe('Example Domain'); }); }); ``` 7. Run Your Test: Compile your TypeScript code using: ```bash npx tsc ``` Then run your test using: ```bash npx jest my-test.js ``` 8. Generate Tests with Codegen (Optional): Playwright comes with a test generator that can create tests based on your interactions with a website. To use it, follow these steps: - Install the VS Code extension for Playwright. - Record your actions in the browser using the extension. - The extension will generate test code directly in VS Code. - You can also generate assertions for visibility, text, and value. - For more details, refer to the official Playwright documentation That's it! You're all set to write and run Playwright tests with TypeScript. Happy testing --

Most welcome

cannot say.. check if its for some limited time..

@@RaghavPal they haven't mentioned anything on their website. Also they are not replying on email and tickets

You can try other options. Here are some options for creating free MySQL databases online that you can use for testing and demo purposes: 1. DB Fiddle: An online SQL database playground where you can test, debug, and share SQL snippets. It's great for experimenting with queries 2. OneCompiler's MySQL Online Editor: Write, compile, debug, run, and test MySQL queries online using OneCompiler 3. db4free.net: Create an account for free and test your applications. It's useful for ensuring your apps work after a MySQL version update and for learning new features --

You can try other options. Here are some options for creating free MySQL databases online that you can use for testing and demo purposes: 1. DB Fiddle: An online SQL database playground where you can test, debug, and share SQL snippets. It's great for experimenting with queries 2. OneCompiler's MySQL Online Editor: Write, compile, debug, run, and test MySQL queries online using OneCompiler 3. db4free.net: Create an account for free and test your applications. It's useful for ensuring your apps work after a MySQL version update and for learning new features --

Thanks Nandan, sure, I have done log4j in selenium java.. if you need can get the steps from there

You're welcome Ashish

Most welcome Marija

Ashish End-to-End (E2E) testing is a comprehensive approach that evaluates the entire software system by simulating real-world user scenarios from start to finish. Here's what you need to know: 1. What is E2E Testing? - E2E testing ensures that the application works as expected from the end user's perspective - It covers the entire workflow, including the user interface, backend services, databases, and network communication - The goal is to validate overall behavior, functionality, reliability, performance, and security. 2. Writing E2E Tests as a Manual Tester: - Identify test scenarios: Understand the user stories and identify the critical scenarios. - Map the steps in each scenario: Break down the user flow into specific steps. - Perform manual testing: Execute the steps manually to verify functionality. - Automate the tests: Once you've validated the manual steps, consider automating them using testing tools or frameworks. - Add your tests to the continuous integration (CI) pipeline for regular execution Remember, E2E testing helps ensure that your application behaves correctly across different layers and interfaces, providing a seamless experience for users --

@@RaghavPal Thank you so much for such a detailed explanation. Thanks a lot on guiding on how to write and perform E2E testing as a manual and automation tester, this really helps me a lot in understanding E2E testing in a broader way.

Great to hear that.. so happy and humbled

Most welcome Harsh

Most welcome

Thanks a lot

Thanks a lot Rahul.. humbled

Thanks a ton Ramana..thanks for your kind words. humbled

Bhagyashree If you're encountering the "Missing Artifact com.sun:tools:jar" error in your `pom.xml`, here are some steps to resolve it: 1. Ensure JDK Installation: - Make sure you have a JDK (Java Development Kit) installed, not just a JRE (Java Runtime Environment). The JDK includes tools like `javac` and `jar`, which are needed during the build process. - Configure Maven to use the installed JDK by setting the `JAVA_HOME` environment variable to the JDK path. 2. Check Maven Dependencies: - Open your project's `pom.xml`. - Look for any dependencies that might require `com.sun.java.tools`. For example, some libraries or plugins might rely on it. - If you find such a dependency, ensure it's correctly specified in your `pom.xml`. 3. Exclude Tools.jar: - If you've identified a problematic dependency, you can exclude `tools.jar` from it. - Locate the dependency in your `pom.xml`. - Add an exclusion for `com.sun:tools:jar` within that dependency. Here's an example of how to exclude `tools.jar` from a dependency: ```xml <dependency> <groupId>your.group.id</groupId> <artifactId>your-artifact-id</artifactId> <version>your-version</version> <!-- Other configuration --> <exclusions> <exclusion> <groupId>com.sun</groupId> <artifactId>tools</artifactId> </exclusion> </exclusions> </dependency> ``` 4. Reload Project: - If you're using an IDE like Eclipse, IntelliJ, or VS Code, reload the project after making changes to the `pom.xml`. - Sometimes, IDEs cache dependencies, and a reload ensures they pick up the changes. Remember to adjust the specifics according to your project setup --

Selva An Expense Tracker project using Java EE with JDBC connectivity can be a valuable addition to your resume. Here's why: 1. Relevance: Expense tracking is a common requirement for individuals and businesses. Demonstrating your ability to create an efficient expense tracker shows practical skills that align with real-world scenarios. 2. Technical Skills Showcase: - Java EE: Employers value knowledge of Java EE (Enterprise Edition) for building robust, scalable applications. - JDBC Connectivity: Understanding how to connect to databases using JDBC is crucial for data-driven applications. 3. Database Interaction: Expense trackers involve database operations (like saving expenses, querying data, etc.). Your project demonstrates proficiency in handling databases. 4. Problem Solving: Implementing features like adding expenses, categorizing them, and searching efficiently showcases your problem-solving abilities. 5. Interview Talking Points: - Discuss the architecture, design patterns, and trade-offs you made. - Explain how you handled security (e.g., preventing SQL injection). - Describe any additional features you implemented (e.g., reporting, user authentication). Remember to emphasize your learning process, challenges faced, and how you overcame them during interviews Additionally, consider exploring open-source projects related to expense tracking to enhance your skills Good luck --

okay.. no worries Harshada

Most welcome

Binita When working with the Page Object Model (POM) in Selenium Python, you need to pass the WebDriver instance (the browser driver) to your page classes. Let’s address this issue: 1. Passing WebDriver to Page Classes: - In POM, each page class should have a `WebDriver` object as a class member. This allows you to interact with web elements on that page. - You can pass the `WebDriver` instance as a parameter to the constructor of your page class. 2. Example Implementation: - Suppose you have a `LoginPage` class. Here's how you can pass the `driver` to it: ```python from selenium import webdriver class LoginPage: def __init__(self, driver): self.driver = driver # Other page elements and methods go here # Usage in your test class: driver = webdriver.Chrome() # Initialize your WebDriver (e.g., Chrome, Firefox, etc.) login_page = LoginPage(driver) # Create an instance of LoginPage ``` 3. Page Factory (Optional): - If you're using Page Factory (a part of POM), you can simplify this further: ```python from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC class LoginPage: def __init__(self, driver): self.driver = driver # Initialize page elements using @FindBy annotations # Usage in your test class: driver = webdriver.Chrome() login_page = LoginPage(driver) ``` Remember to adjust the class name (`LoginPage` in this example) to match your actual page class --

Ramya The error you're encountering with Playwright and WebKit-specifically, the "Error: browserContext.newPage: Target page, context, or browser has been closed"-can be tricky to troubleshoot. Let's explore some potential solutions: 1. Browser Context Lifecycle: - This error often occurs when a browser context or page is closed prematurely. Ensure that you're managing browser contexts correctly. - Make sure you're not closing a context or page before attempting to use it in subsequent steps. 2. Webkit-Specific Issues: - WebKit might have specific quirks or limitations. Consider checking the Playwright documentation for any known issues related to WebKit. - Update Playwright to the latest version. Sometimes, newer versions include fixes for specific browser-related problems. 3. Network Idle vs. DOMContentLoaded: - You mentioned using `networkIdle` for Chrome. Try using `domcontentloaded` instead for WebKit. - WebKit might behave differently during page navigation events. Adjust the wait strategy accordingly. 4. Headless Mode: - You mentioned running the tests in headless mode. Try running them without headless mode to see if the issue persists. - If the issue disappears, it might be related to headless mode in WebKit. 5. Debugging: - Add logging statements to your test steps. Print messages before and after each navigation action to see where the issue occurs. - Use `console.log` or similar methods to track the flow of your test. 6. Playwright Updates: - Ensure you're using the latest version of Playwright. Run `npm install -D @playwright/test@latest` to update. - Check the release notes for any browser-specific fixes. Remember that debugging browser automation can be challenging, but systematically narrowing down the issue will help you find a solution. Good luck --

Most welcome Keith