Getting started update

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "spellchecker.ignoreWordsList": [
+        "reponsibilies"
+    ]
+}

context/get-started-now.md

@@ -0,0 +1,186 @@
+# Get Started Now
+
+Welcome, early adopters! If you're eager to try the current version of Power Platform Automated Testing, you're in the right place. This guide will help you get started with the necessary components and provide you with two paths to explore automated testing.
+
+## Prerequisites
+
+To get started, you'll need the following components:
+1. **Ability to Clone Repository**: Use Git command line or GitHub Desktop to clone the repository.
+2. **PowerShell**: Ensure you have PowerShell installed on your machine.
+3. **Power Platform Command Line Tools**: Install the Power Platform Command Line tools to interact with your Power Platform environment.
+4. **.NET 8.0 SDK**: Download and install the .NET 8.0 SDK to build the code.
+
+This can seem daunting but the following steps will help you with this process assuming you are using Microsoft Windows as your local operating system.
+
+These install steps ise [winget](https://learn.microsoft.com/windows/package-manager/winget/#install-winget) for install. 
+
+## Ability to Clone Repository
+
+To install a GitHub client you can follow these steps. You can also follow [Download GitHub Desktop](https://desktop.github.com/download/) to download the application
+
+1. If you don't already have Git installed, you can install it using `winget`:
+
+```pwsh
+winget install --id Git.Git -e --source winget
+```
+
+2.  Alternatively, you can use GitHub Desktop. Install it using `winget`:
+
+```winget
+winget install --id GitHub.GitHubDesktop -e --source winget
+```
+
+3. Use Git command line or GitHub Desktop to clone the repository. For Git command line, open your terminal and run:
+
+```pwsh
+git clone https://github.com/microsoft/PowerApps-TestEngine.git
+```
+
+4. **Verification**: After cloning, navigate to the repository folder and list the contents to ensure the files are there:
+
+```pwsh
+cd PowerApps-TestEngine
+```
+
+## PowerShell
+
+PowerShell is typically pre-installed on Windows. But for these instructions we assume PowerShell Core is assumed. You can also follow instructions on [Installing](https://learn.microsoft.com/en-us/powershell/scripting/install/installing-powershell) for different operating systems.
+
+1. PowerShell Core can be installed using `winget`:
+
+```cmd
+winget install --id Microsoft.PowerShell --source winget
+```
+
+2. **Verification**: Run the following command in PowerShell Core to check the version:
+
+```bash
+pwsh --version
+```
+
+## .Net 8.0 SDK
+
+You can install the .Net 8.0 SDK using the following commands in Microsoft Windows. You can also follow [Download .NET 8.0](https://dotnet.microsoft.com/download/dotnet/8.0) for different operating systems and install steps.
+
+1.  Download and install the .NET 8.0 SDK using `winget`:
+
+```bash
+winget install Microsoft.DotNet.SDK.8 
+```
+
+2. **Verification**: Verify the installation by running:
+
+```pswh
+dotnet --version
+```
+
+3. Close and reopen your terminal to ensure the new components are in the system path.
+
+##  Power Platform Command Line Interface (CLI)
+
+You can install the .Net 8.0 SDK using the following commands in Microsoft Windows. We can also follow [Install Microsoft Power Platform CLI](https://learn.microsoft.com/power-platform/developer/cli/introduction#install-microsoft-power-platform-cli) for different operating systems and install types.
+
+1. Install Power Platform Command Line Interface (CLI) using dotnet command line interface
+
+```pwsh
+dotnet tool install --global Microsoft.PowerApps.CLI.Tool
+```
+
+2. **Verification**: Verify the installation by running:
+
+```pswh
+pac -v
+```
+
+3. Close and reopen your terminal to ensure the new components are in the system path.
+
+## Getting Started
+
+Have the prerequisites installed and verified? If so lets looks at some samples to get started. For each sample reference the README.md for more information.
+
+### Sample Configuration Settings
+
+Each of the samples will need a **config.json** file in the folder using the following format. This file should be placed in each samples folder as the same level as `RunTest.ps1`
+
+```json
+{
+    "tenantId": "a222222-1111-2222-3333-444455556666",
+    "environmentId": "12345678-1111-2222-3333-444455556666",
+    "customPage": "admin_initialsetuppage_d45cf",
+    "user1Email": "[email protected]",
+    "runInstall": true,
+    "installPlaywright": true
+}
+```
+
+To complete this file
+
+1. Open `https://make.powerapps.com`
+
+2. Navigate to the Environment you want to test
+
+3. On the command bar, select Settings (gear)
+
+4. Select **session details**
+
+5. Copy the Environment Id and Tenant Id to the config.json file you have created
+
+6. Update user1Email to your test user email address.
+
+7. Note: Some samples will not require the customPage setting
+
+### Git Branch Notes
+
+Samples are currently in the `grant-archibald-md/integration-merge` branch as changes are reviewed and updated they will move to main and the Power Platform `pac test run` command. To use this branch
+
+```pwsh
+git checkout grant-archibald-md/integration-merge
+```
+
+### Simplest Example: Clicking the Button of a Canvas App
+
+For those looking for a straightforward example, you can start with a simple scenario like clicking a button in a Canvas App. This example will help you understand the basics of automated testing in the Power Platform.
+
+1. Import the ButtonClicker_*.zip file from the cloned repository using [Import solutions](https://learn.microsoft.com/power-apps/maker/data-platform/import-update-export-solutions)
+
+2. Copy you completed config.json file into the folder
+
+3. Run the test
+
+```pwsh
+pwsh -File RunTests.ps1
+```
+
+### Advanced Example: CoE Starter Kit Setup and Upgrade Wizard
+
+For a more comprehensive example, you can explore the CoE Starter Kit Setup and Upgrade wizard. This low-code solution offers a broader scope for testing and provides a deeper understanding of automated testing in the Power Platform.
+
+### Running tests
+
+1. Install the CoE Kit using [Get started with setup](https://learn.microsoft.com/power-platform/guidance/coe/setup)
+
+2. Copy you completed config.json file into the folder
+
+3. Run the test
+
+```pwsh
+pwsh -File RunTests.ps1
+```
+
+### Recording new tests
+
+To Optionally record a new test based on your input and Dataverse and Connector calls you can
+
+1. Launch the application in 
+
+```pwsh
+pwsh -File Record.ps1
+```
+
+5. When in record model wait until the [Playwright Inspector](https://playwright.dev/docs/debug#playwright-inspector) appears
+
+6. Interact with the application
+
+7. Select continue in the Playwright Inspector to complete the session
+
+8. The test results will indicate where to look at the recorded test results

context/getting-started-architects.md

@@ -0,0 +1,31 @@
+## Architects
+
+Architects play a pivotal role in the successful implementation of Power Platform Automated Testing. Your expertise and strategic oversight are essential to ensure that low-code solutions are robust, scalable, and aligned with organizational goals. By embracing automated testing, you can drive innovation and enhance the quality of your solutions.
+
+### Why Should Architects Care?
+
+Automated testing in the Power Platform allows you to:
+- **Ensure Quality**: Implement rigorous testing standards to validate the functionality and performance of low-code solutions.
+- **Enhance Integration**: Seamlessly integrate low-code solutions with existing IT investments, ensuring a cohesive technology ecosystem.
+- **Drive Innovation**: Enable rapid iteration and improvement of solutions, staying ahead of the competition.
+- **Maintain Compliance**: Ensure that solutions comply with industry standards and organizational policies through consistent testing.
+
+### Call to Action
+
+Start planning for the impact of low-code automated testing today. Here are some steps you can take:
+1. **Review Frameworks**: Familiarize yourself with the [Power Well-Architected Framework](https://aka.ms/powa) and other relevant guidelines.
+2. **Establish Standards**: Define and implement quality control measures and best practices for development, testing, and deployment.
+3. **Collaborate Across Teams**: Work closely with other architects, developers, and business stakeholders to ensure holistic integration.
+4. **Leverage Existing Investments**: Adapt existing testing frameworks and tools to support low-code solutions.
+5. **Pilot Projects**: Initiate small pilot projects to gather insights and refine your testing processes.
+
+By taking these steps, you can leverage the full potential of low-code automated testing to drive innovation and achieve your organizational goals.
+
+## Architects Roles
+
+| Role | Description |
+|------|-------------|
+| [Enterprise Architects](../roles-and-responsibilities/enterprise-architects.md) | Review the pillars of the [Power Well-Architected Framework](https://aka.ms/powa) and implement quality control and integration with other information technology investments. They ensure holistic integration across low-code and code-first investments. |
+| [Solution Architects](../roles-and-responsibilities/solution-architects.md) | Implement enterprise standards and make recommendations on how enterprise plans could be executed. They ensure a robust ALM process that includes building, implementing, reviewing, and deploying low-code solutions. |
+| [DevOps Engineers / Architects](../roles-and-responsibilities/devops-engineers-architects.md) | Responsible for the overall Continuous Integration / Deployment process and integrating Power Platform into this process. They manage source control integration, test assets, and quality processes for deployment and updates. | 
+| [Security Architects](../roles-and-responsibilities/security-architects.md) | Manage cybersecurity and data privacy, ensuring that solutions do not expose the organization to risk. They ensure compliance with security standards and manage secure deployment 

context/getting-started-business.md

@@ -0,0 +1,34 @@
+# Getting Started Business Roles
+
+Business users play a crucial role in the successful implementation of Power Platform Automated Testing. As early adopters, your involvement and feedback are essential to drive innovation and ensure the solutions meet your needs. By embracing low-code automated testing, you can significantly enhance the efficiency and reliability of your business processes.
+
+### Why Should Business Users Care?
+
+Automated testing in the Power Platform allows you to:
+- **Improve Efficiency**: Automate repetitive testing tasks, freeing up time for more strategic activities.
+- **Enhance Quality**: Ensure that your solutions are robust and perform as expected, reducing the risk of errors.
+- **Drive Innovation**: Quickly iterate and improve your solutions, staying ahead of the competition.
+- **Ensure Compliance**: Maintain compliance with industry standards and regulations through consistent and thorough testing.
+
+### Call to Action
+
+Start planning for the impact of low-code automated testing today. Here are some steps you can take:
+1. **Identify Key Processes**: Determine which business processes would benefit most from automated testing.
+2. **Collaborate with IT**: Work closely with your IT department to understand the technical requirements and capabilities of the Power Platform.
+3. **Invest in Training**: Ensure that your team has the necessary skills and knowledge to effectively use automated testing tools.
+4. **Pilot Projects**: Begin with small pilot projects to test the waters and gather valuable insights.
+5. **Gather Feedback**: Continuously collect feedback from users to refine and improve your testing processes.
+
+By taking these steps, you can leverage the full potential of low-code automated testing to drive innovation and achieve your business goals.
+
+## Business Roles
+
+You can also review the following to drive deeper depending on your specific role or responsibilities:
+
+| Role | Description |
+|------|-------------|
+| [Business Stakeholders](../roles-and-responsibilities/business-stakeholders.md) | Represents business stakeholders who have invested in the Power Platform and want to ensure automated testing is applied at the correct level. They are concerned with business continuity, solution performance, and mitigating security risks. |
+| [Business Unit Leads](../roles-and-responsibilities/business-unit-leads.md) | Responsible for achieving goals set by business stakeholders and demonstrating the impact and quality of the solutions created. | 
+| [Managers](/powerfuldev-testing/roles-and-responsibilities/managers) | Ensure that makers or software developers in their teams have the required knowledge and training to effectively build and test solutions. They also focus on succession planning and sharing successful solutions among the team. | 
+| [Makers](../roles-and-responsibilities/makers.md) | Low-code maker community who build solutions using low-code tools to rapidly achieve business goals. They may be unfamiliar with formal testing skills and need low-code testing processes to create sustainable solutions. |
+| [Trainers](../roles-and-responsibilities/trainers.md) | Responsible for enterprise training and skilling by role to make the most of low code Power Platform |

context/getting-started-technical.md

@@ -0,0 +1,34 @@
+## Technical Users
+
+Technical users are at the forefront of implementing and optimizing Power Platform Automated Testing. Your technical expertise and willingness to adopt new technologies are crucial for driving innovation and ensuring the success of low-code solutions. By embracing automated testing, you can enhance the quality and efficiency of your development processes.
+
+### Why Should Technical Users Care?
+
+Automated testing in the Power Platform allows you to:
+- **Improve Productivity**: Automate repetitive testing tasks, freeing up time for more complex development work.
+- **Ensure Quality**: Implement rigorous testing standards to validate the functionality and performance of low-code solutions.
+- **Stay Ahead**: Adopt the latest features and tools to continuously improve your solutions.
+- **Enhance Collaboration**: Work seamlessly with other teams to ensure a cohesive development process.
+
+### Call to Action
+
+Start planning for the impact of low-code automated testing today. Here are some steps you can take:
+1. **Explore New Features**: Follow a build-from-source strategy to try the latest features now or wait until new features are available in the Power Platform Command Line.
+2. **Establish Testing Frameworks**: Define and implement automated testing frameworks that align with your development processes.
+3. **Collaborate with Teams**: Work closely with other technical users, architects, and business stakeholders to ensure holistic integration.
+4. **Leverage Existing Tools**: Adapt existing testing tools and frameworks to support low-code solutions.
+5. **Pilot Projects**: Initiate small pilot projects to gather insights and refine your testing processes.
+
+By taking these steps, you can leverage the full potential of low-code automated testing to drive innovation and achieve your development goals.
+
+## Technical User Roles
+
+| Role | Description |
+|------|-------------|
+| [Software Engineers](../roles-and-responsibilities/software-engineers.md) | Use Power Platform to augment their existing code-first skills as a productivity tool or contribute extensions or add-ons to help makers achieve more. |
+| [Support Engineers](../roles-and-responsibilities/support-engineers.md) | Take ownership of low-code solutions to help them scale across the organization. They focus on the quality of low-code solutions and the ability to support and fix them. | 
+
+## Get Hands On Now
+
+Want to work with the latest components follow get me hands on to start recording any authoring your tests today. [Read more](./get-started-now.md)
+