DEV Community: Dogu Technologies

Dogu v2.0.0: Run routine with latest app, License policy and admin settings for self-hosted, Browser video recording, and more

Daniel Ahn — Mon, 18 Sep 2023 14:15:53 +0000

In this update, Dogu's major version has been changed! With this update, we have addressed the issue of specifying the app version in routines, improving convenience. We have also introduced the ability to apply and configure licensing (pricing) policies in self-hosted environments. Take a closer look!👀

✨ Run routine with latest app

In the previous v1.11.0 update, we introduced support for Routine with mobile app and games. Routine was structured as follows at that time.

name: app_test

on:
  workflow_dispatch:

jobs:
  test-android:
    runs-on:
      group:
        - android
    appVersion:
      android: 1.0.0
    record: true
    steps:
      - name: run test
        uses: dogu-actions/run-test
        with:
          checkout: true
          environment: python
          command: |
            pip install -r requirements.txt
            pytest app/test_android.py --capture=no -x
        cwd: app/python/pytest

This involves locating and installing an app with version 1.0.0 on all devices with the android tag and executing a test script while performing routines. You can run routines and view the results. So far, everything seems fine!

However, when integrating routines with CI, there is a slight inconvenience. Why is that? It's because the routine mentioned above always runs an app with version 1.0.0. During the process of uploading the app built in the CI workflow, the app version can dynamically change. Therefore, Dogu defines the latest app based on the app build version and specifies the app package name in routines, allowing you to run the latest app with that package name! Awesome!😎

The above routine can be replaced with the following:

name: app_test

on:
  workflow_dispatch:

jobs:
  test-android:
    runs-on:
      group:
        - android
    appPackageName:
      android: com.dogu.sample
    record: true
    steps:
      - name: run test
        uses: dogu-actions/run-test
        with:
          checkout: true
          environment: python
          command: |
            pip install -r requirements.txt
            pytest app/test_android.py --capture=no -x
        cwd: app/python/pytest

In this routine, it locates the app among the uploaded apps with the package name com.dogu.sample and selects the one with the highest build version to execute.

Furthermore, you can also see which app is the latest one in the project app list from the console!

✨ License policy and configuration for self-hosted

The reason for the change in Dogu's major version is as follows. Our team members engaged in extensive discussions and deliberations regarding the Dogu's direction and business model, considering various valuable insights. Initially, decisions were made after converging on several key points.

Firstly, in the self-hosted environment, there will be differences in functionality between the Community Edition and the Professional Edition. These differences will encompass the number of devices and runners available, routine CI integration, and additional support features such as technical support.

For detailed information about the Professional Edition or inquiries regarding experiencing it, please visit the Pricing page below.

Dogu Pricing

As a result of this, we have introduced the concept of a root user in the self-hosted environment. When you first run in the self-hosted mode, you can now sign up with a root account and configure license.

In self-hosted Dogu, if you are a root user, you will find the "Admin settings" menu in the top header - Profile menu. Clicking on that menu will take you to a page where you can set up your license.

There are a few things to set up to register your license in a self-hosted environment, visit our guide!

In the cloud environment, it appears that there will be different pricing plans prepared in a different way. We will provide further guidance on this through future updates.

✨ Browser screen records in routine result report

One of the most helpful things you can find in your test results report is a video recording of your test screen. If a test fails, you can intuitively see why it failed. This feature was previously only available for mobile apps and games, but this update brings it to the web!

Browser records in routine result report

✨ Host device with runner

In Dogu, a host machine can also be used as a device. In this case, the host device is special and can have multiple Runners. You'll use these Runners when you run web tests on the host device, and you'll use one Runner for one browser.

Runners can now be changed in the Runner settings menu. Just enter how many browser runners you want to use!

Host device with runners

Now, when you run the web test using the host device, the usage state of each runner will change. If you run the test on the Chrome, Safari, and Firefox browsers at the same time, runners 1 through 3 will change to the running state.

Wrapped up

In this update, we've improved usability by using package names instead of app versions in routines, provided browser recordings in web test results reports for richer results. Furthermore, we bumped up the major version to self-hosted with licensing. We're offering a free trial on self-hosted, so give it a try!

Dogu Technologies - Seamless Test Automation Platform

Revolutionize your testing workflow with our game and application test automation platform. Execute automated tests using Dogu and optimize your software quality assurance.

dogutech.io

If you have any questions or need assistance, feel free to reach out via email at contact@dogutech.io, or consider joining our Dogu Slack Community where you'll find a warm welcome and support. We're always here to help!

Happy Testing!

Dogu v1.11.0: Cross-browsing, Mobile app and Game test with Routine, Routine GUI editor, Dogu Studio live user session, and more

Daniel Ahn — Sat, 09 Sep 2023 11:03:14 +0000

The test automation platform Dogu has been updated to version 1.11.0!🚀 In this update, the routine feature, which is one of the powerful test automation functionalities that allows you to define and seamlessly integrate your automated testing workflows with CI/CD, has received significant enhancements.

Dogu Technologies - Seamless Test Automation Platform

Revolutionize your testing workflow with our game and application test automation platform. Execute automated tests using Dogu and optimize your software quality assurance.

dogutech.io

Routine is a core feature in Dogu that assist with test automation. Let's take a closer look at how it has been updated!😎

✨ Major updates in Routine

Support cross-browsing automation

When creating web-based products, it quickly becomes apparent that focusing on just one browser is not enough. Because of this, web developers often find themselves testing and developing across multiple browsers, or QA teams need to conduct tests in various browsers as well, which can negatively impact product productivity.

To address this challenge, Dogu has updated its routines to allow you to perform tests simultaneously across multiple browsers using a single web testing script. Dogu initially supports Chrome, Safari (macOS), Firefox, and Edge browsers. Worried that you don't have all the required browsers installed for testing? Don't fret! In Dogu, you can easily manage and run tests across these browsers without any hassle.

Dogu supports web testing through Selenium. You can write test scripts using Jest or Pytest and then review detailed results in the routine report.

A routine with 4 parallel web test jobs

* Mobile browsers will be supported in the next update.

Support mobile app test automation

Mobile apps are also a target for Dogu's automation testing. Script-based app test automation typically requires knowledge of Appium(ie. capabilieties...), but Dogu has reduced the learning curve by simplifying the automation process, making it easy to use.

Dogu allows you to perform Android and iOS app testing through Appium (WebdriverIO) within Routine. In the example test scripts, testing is performed using XPath for element identification. And in Dogu Studio, you can easily find XPath for elements within the app using the UI Inspector. You can create mobile app tests using Pytest or Jest and then review detailed test reports, including logs, CPU and memory usage and more, on a test-by-test basis, all available in the routine results page.

Running mobile app testing using Appium

Support game test automation

One of Dogu's strengths is its ability to automate game testing. Through Gamium , you can retrieve XPaths for elements within the game and write scripts using popular testing frameworks like Jest or Pytest. Furthermore, they can display test-specific statuses and results in routine reports including logs, CPU and memory usage, in-game FPS and more!

You can obtain the XPath for game elements either by using the UI Inspector feature in Dogu Studio or through GamiumEditor in the Unity Engine. For more details, please refer to the UI Inspector and GamiumEditor documentation.

Running game testing using Gamium

GUI Editor and Tutorial

With the routine update, we've also enhanced the GUI editor to improve UX. In the previous v1.10.0 update, we introduced the project template feature. In this update, the features available in the routine GUI editor will vary depending on the template you choose, and the tutorials have been updated to align with the selected template.

App and Game template(top) and Web template(bottom)

The updated GUI editor has been improved to make it easy to create basic test automation routines even if you're not familiar with YAML syntax.

Additionally, tutorials are provided for routines. To create a routine, you'll go through steps like Git integration and routine scripting before you can try running the routine. You can always revisit the tutorials on the routine page for guidance. With the help of these tutorials, you can implement test automation in Dogu in just a few minutes, alongside the provided examples!

Through routines, you can perform cross-browser testing and cross-platform testing simultaneously across multiple browsers or devices. Furthermore, routines exhibit their full potential when integrated with CI/CD tools. For detailed examples, please refer to the guide documentation!

✨ Dogu Studio live user session

Dogu includes the Dogu Studio feature, which allows you to stream and remotely control devices registered in the device farm. Now, a convenience feature has been added to Dogu Studio, enabling you to see which members are currently streaming the device.

Dogu Studio with members

Wrapped up

With this latest update, the routine feature, which allows you to perform test automation in practice, has been significantly enhanced, resulting in a substantial increase in Dogu's usability. Creating test routines with Dogu and integrating them with CI/CD to execute routines will undoubtedly boost both product productivity and quality.

Dogu Technologies - Seamless Test Automation Platform

Revolutionize your testing workflow with our game and application test automation platform. Execute automated tests using Dogu and optimize your software quality assurance.

dogutech.io

Happy Testing!

Dogu v1.10.0: Git integration with Bitbucket, CI integration with Jenkins plugin and GitHub Action, and more

Daniel Ahn — Sat, 02 Sep 2023 08:53:41 +0000

Dogu has been updated to v1.10.0! 🚀 We're continuously sprinting ahead for efficient test automation.

dogu-team / dogu

The Unified Test Automation Platform

Dogu - Seamless Unified Test Automation Platform

What's Dogu?

Dogu is a seamless unified test automation platform for web, mobile and game application. You can integrate various tools such as Appium, Selenium and Playwright that you have previously used with Dogu, allowing you to perform parallel processing and check test results more easy. Experience more efficient test automation with Dogu.

Architecture

Dogu is a test automation platform that provides a seamless unified experience for web, mobile and game application. Dogu is composed of the following components.

Dogu Features

Device Farm

Build a systematic device farm with Windows, MacOS, Android, and iOS devices.

Device Studio

Control devices remotely with Device Studio.

Inspecting UI

Inspect UI with Device Studio.

Test CI

Run test parallelly and periodically with routine.

Test Report

Visualize test unit by integrating test unit framework with report.

Start Dogu

With Self-Hosted

Use Dogu on a self-hosted. See guide setting…

View on GitHub

In this latest update, numerous features have been added and improved, including Git repository integration, Jenkins and GitHub integration, and much more. Let's dive into the details!

✨ Integration with Bitbucket

In Dogu, the Routine feature is one of the powerful capabilities for automating complex tests or performing tests in integration with CI. Routine takes the user's Git repository and allows for the execution of specific test scripts.

Until now, Dogu has supported integration with GitHub and GitLab repositories. Upon receiving user feedback and requests, we have decided to extend our support to integrate with Bitbucket as well. (Thank you for your all feedbacks! 😄)

Bitbucket repository integrated!

Following the integration with Bitbucket, when creating or modifying routines in GUI editing mode, you'll now be able to fetch test scripts from the linked repository during the step where you execute tests!

Options for test scripts

To integrate with Bitbucket, you'll need either a Repository access token or a Project access token provided by Bitbucket. For detailed information, please refer to our documentation at Bitbucket Integration.

✨ Jenkins plugin and GitHub Action

As mentioned earlier, Dogu Routine is designed to seamlessly integrate routines with CI for execution. Dogu provides functionality to run routines through Jenkins plugin and GitHub Actions!

jenkinsci / dogu-integration-plugin

Dogu Integration Plugin

Description

Dogu is an cross E2E test automation platform for web, mobile and game application. You can integrate various tools such as Appium, Selenium and Playwright that you have previously used with Dogu, allowing you to perform parallel processing and check test results more easy. Experience more efficient test automation with Dogu.

This plugin helps to integrate jenkins with Dogu.

Features

Dogu Credential

You can add Dogu access token to Jenkins credential store. Dogu Organization Token and Dogu Project Token are supported.

Dogu Run Routine Build Step

You can run a routine in Jenkins. You can specify the Dogu project and routine by ID.

How it works

When you add a Dogu Credential, it will be added to the Jenkins credential store. The Dogu Run Routine Build Step will use the Dogu Credential to connect to Dogu and run the routine.

Development

Getting Started

mvn hpi:run

…

View on GitHub

dogu-team / dogu-github-action

Dogu Github Action

Integrate github action with Dogu

Common Inputs

`template`

run_routine
upload_application

`api-url` (optional)

Default: https://api.dogutech.io

`timeout` (optional)

Default: 60 * 60 * 1000 (ms)

Templates

`run_routine`

Inputs

project-id
routine-id

`upload_application`

Inputs

project-id
file-path

Env

`DOGU_TOKEN`

Organization Token, Project Token, User Token can be used.

Example usage

- name: Upload Application
  uses: dogu-team/dogu-github-action@v1.0
  with:
    template: upload_application
    project-id: 'a5792d9b-a8e8-4ab8-b790-3a503c5a8789'
    file-path: '/usr/project/build/app.apk'
  env:
    DOGU_TOKEN: ${{ secrets.DOGU_TOKEN }}

- name: Run Routine
  uses: dogu-team/dogu-github-action@v1.0
  with:
    template: run_routine
    project-id: 'a5792d9b-a8e8-4ab8-b790-3a503c5a8789'
    routine-id: 'c3218f5f-02bf-43a1-9eb3-acd2753e7567'
  env:
    DOGU_TOKEN: ${{ secrets.DOGU_TOKEN }}

View on GitHub

To test mobile apps or game products, you need to upload the app you want to test to your Dogu project. This is because routines use the app on devices to execute tests. To do this as part of your CI process, you can perform the following actions using the Jenkins plugin and GitHub Action:

Upload the app to your Dogu project.
Trigger the execution of the defined routine.

For details, please visit Jenkins plugin and GitHub Action documentations!

✨ Project template for your products

Dogu provides test automation capabilities for web(including mobile web), mobile apps, and games. As a result, there arose a need to offer different features or GUI editors based on the user's product type within a project. For instance, a user looking to test a web service might not require a menu to upload a mobile app.

After our team members contributed various valuable insights, we decided to introduce the option to choose project templates when creating a project. From now on, you can focus only on the features you need when testing your own product.

Options for project template

Web template sidebar menu vs App template sidebar menu

Currently, we only offer a difference in the presence of the project app uploading feature. However, there are exciting changes on the horizon, including upcoming enhancements to the GUI editing functionality within routines, tailored test result reporting, and some alterations to features and the UI. We look forward to your anticipation of these upcoming developments :)

Wrapped up

Alongside the Bitbucket integration feature, Dogu is actively developing functionalities and improvements based on user feedbacks gathered from the Dogu Slack Community. Once again, we extend our gratitude for everyone's valuable feedback! With the addition of the project template feature, Dogu has gained greater scalability, and in the future, you can expect differences in UI and functionality between templates. These newly added and updated features appear to be a significant step toward Dogu's goal of becoming an "efficient and user-friendly test automation platform."

Happy Testing!

How Are E2E Tests Performed for Test Automation Product? - Dogu E2E Testing Implementation

Daniel Ahn — Mon, 14 Aug 2023 08:08:26 +0000

This post is translated to English from original post.

When Dogu was not yet an open-source product, we connected our office equipment to GitHub Runner and set it up to execute E2E tests whenever a commit was made, fetching the code from the Runner device. At that time, our test case count was relatively low. However, when we started open-sourcing Dogu, we temporarily paused the E2E tests as we detached the private GitHub Runner. After about a month and a half following the open-sourcing, we reconfigured the E2E tests, and we'd like to share that journey.

dogu-team / dogu

Dogu is unified test automation platform for cross platform game and app

Dogu - Seamless Unified Test Automation Platform

We are preparing for re-building project to open source

What's Dogu?

Architecture

Dogu is a test automation platform that provides a seamless unified experience for web, mobile and game application. Dogu is composed of the following components.

Test CI Architecture

Dogu Features

Device Farm

Build a systematic device farm with Windows, MacOS, Android, and iOS devices.
Real devices and emulators are supported.

Device Studio

Control devices remotely in Device Studio.

Inspecting UI

Inspect UI with Device Studio.

Test CI

Run test parallelly and periodically with routine.

Test Report

Visualize test unit by…

View on GitHub

TL;DR

Previously, E2E testing for Dogu was lacking, but efforts were made to improve it after open-sourcing. Transitioned from using private GitHub Runner to utilizing Dogu for E2E testing. Set up the test environment connection for local testing. Leveraged Dogu routine functionality for simultaneous execution on multiple platforms. Employed dogu-github-action for automated E2E test integration. Enhanced efficiency and reduced developer workload through CI integration, leading to improved product quality.

Testing for Dogu

Before open-sourcing, E2E testing covered a smaller portion compared to the product's features. (The Dogu team focused more on feature development initially..🥲) We decided to implement QA within the team before releasing, and during the approximately one and a half months when E2E was paused, release days felt like entering a battlefield. It was a war with testing, where we had to manually test many features, and we had three different platforms to test.

"□□□ should be tested on a MaZc ARM64 device, and for △△△, please test it on a Windows x64 device."

"Who will handle testing on Mac x64?"

...

Such extensive and repetitive testing on release days, coupled with the need for quick fixes upon issue discovery, led to a constant busy cycle. Does this sound familiar? This is evidence of the need for automated E2E testing! 😎

During this period, someone from outside posed the question, "How do you test Dogu?" At that time, Dogu lacked many features for testing. We reached a conclusion that we needed to use Dogu extensively ourselves to understand its helpful aspects and areas for improvement, leading us to the idea of "Using Dogu to perform Dogu E2E testing!" So, with minimal effort, we decided to reintegrate E2E into CI.

Challenges Faced...

Although E2E testing seemed easily attainable, the process didn't always align with our expectations...😭 We encountered numerous minor issues, but a few significant challenges were particularly hindering.

Running Locally

Our previous approach involved building Docker images after each commit, uploading them to a cloud repository, fetching them onto server equipment, and then executing them on E2E devices. However, due to cost and time concerns, we decided to revert to the pre-open-source approach of fetching E2E devices locally for testing, instead of relying on the cloud.

However, post open-sourcing Dogu, GitHub Docs recommended using private repositories, prompting us to remove most of our private GitHub Runners. To adhere to this guidance while testing Dogu through Dogu, we connected E2E devices to the internal test Dogu environment using Dogu itself. We tuned the Dogu Agent app used for connecting the test environment to the E2E device, enabling Dogu Agent execution for E2E on the local E2E device. This was necessary due to potential conflicts when two Dogu Agents recognize the device simultaneously during Dogu E2E tests involving device streaming functionality.

Controlling Multiple Clients Simultaneously

Dogu uses a web browser and a desktop app for device farm setup. We needed to launch both clients on the E2E test device. While our automation testing features included remote testing and routines, they were insufficient for testing across multiple devices. Remote testing allowed users to test scripts on locally connected devices to Dogu before committing to the repository. However, testing multiple devices and running two clients simultaneously were not yet possible.

Hence, we opted for a routine that allows concurrent execution across multiple devices and is scalable. Routines could be written in GUI or YAML, and actions provided by routines allowed for executing scripts across various environments (platforms). Dogu E2E tests were configured to run on macOS ARM64, macOS x64, and Windows devices within a single routine. We also added Git integration to Dogu to facilitate local execution.

Below is an example YAML format used to test Dogu with the routine!

name: e2e
on:
  workflow_dispatch:
jobs:
  e2e-macos:
    runs-on:
      group:
        - e2e-macos
    steps:
      - name: env
        run: printenv

      - name: fix diverged main
        run: git reset --hard origin/main

      - name: Checkout
        uses: dogu-actions/checkout
        with:
          clean: true

      - name: create dotEnv
        run: |
          ~/.dogu_bin/env-generator gen-all e2e

      - name: Run newbie
        run: yarn newbie:cicd

      - name: Run newbie:python
        run: export PATH=/opt/homebrew/bin:/usr/local/Cellar/poetry/1.5.1/bin:$PATH && yarn newbie:python

      - name: Build Projects
        run: printenv && yarn workspace dogu run build

      - name: Run influx, pgsql, redis, nexus, turn-server
        run: |
          yarn workspace console-web-server run start:e2e-background
        env:
          PATH: /usr/local/bin:$PATH

      - name: Newbie nm-space
        run: yarn workspace dogu run newbie:nm-space

      - name: Build nm-space
        run: cd nm-space && yarn workspace nm-space run build

      - name: Download, Build third-party
        run: |
          export PATH=/opt/homebrew/bin:/usr/local/Cellar/cmake/3.27.0/bin:/usr/local/go/bin:$PATH && yarn third-party:download:build     

      - name: Run e2e
        run: |
          yarn workspace e2e run util:install-chromedriver && yarn workspace e2e run start:ci

    record: true
  e2e-windows:
    runs-on:
      group:
        - e2e-windows
    steps:
      - name: Printenv
        run: set

      - name: Checkout
        uses: dogu-actions/checkout
        with:
          clean: true

      - name: create dotEnv
        run: |
          $HOME/.dogu_bin/env-generator gen-all e2e

      - name: Run newbie
        run: yarn newbie:cicd

      - name: Run newbie:python
        run: yarn newbie:python

      - name: Build Projects
        run: set && yarn workspace dogu run build

      - name: Run influx, pgsql, redis, nexus, turn-server
        run: |
          yarn workspace console-web-server run start:e2e-background

      - name: Newbie nm-space
        run: yarn workspace dogu run newbie:nm-space

      - name: Build nm-space
        run: cd nm-space && yarn workspace nm-space run build

      - name: Download, Build third-party
        run: |
          yarn third-party:download:build

      - name: Run e2e
        run: |
          yarn workspace e2e run util:install-chromedriver && yarn workspace e2e run start:ci
    record: true

Integration with CI

Now we were prepared! Simply executing the Dogu routine after each commit was all it took. However, we needed to enable running the Dogu routine within GitHub Action. To achieve this, we created a GitHub Custom Action to run the Dogu routine in GitHub Action. This led to the creation of the dogu-github-action!

While it currently doesn't retrieve logs or similar information from Dogu, it waits until the routine is finished. Once completed, it provides the routine result URL, and it meets minimal requirements for handling cancellations of routines or GitHub Actions.

Writing Test Scripts

Dogu E2E test scripts were written using our team's internally developed testing framework called Dest and Selenium, Playwright. Dogu web uses Selenium, while Dogu Agent is a desktop app built with Electron, so we tried Playwright for scripting. (We plan to switch to Jest or Pytest as Dest won't be further developed!)

Existing E2E scripts were written based on previous specifications, covering around 30 test cases. We enhanced the scripts to cover more than 130 cases. Using unique or reliably identifiable attributes like id, rather than relying solely on Full XPath, we designed the XPath for scripting to address changes in web UI or the addition of new elements.

Now, many of Dogu's features are tested through E2E, with tests executed with each commit! This brings us more comfort during development. E2E tests can identify abnormal behavior resulting from code changes.

Happy Testing!

Let's take a look at recent E2E test results. All tests passed except on macOS ARM64 device.

We need to investigate the cause of the failure on Mac mini device.

From the logs, it seems we couldn't find an element matching //*access-id="add-host-form-name" XPath. This information is insufficient to determine the issue and actions performed. To address this, we recorded device operations during the routine using record: true, allowing us to review the recorded video and gain insight into the exact actions taken.

This recording capability greatly facilitates debugging. Even if E2E tests fail, debugging time is significantly reduced, making it easier to identify and rectify issues.

In Conclusion...

Now, E2E tests are performed not just on release days but with every commit or PR, reducing the need for last-minute preparations on release days. With Dogu routines and test script writing, tasks that previously required manual repetition, from user registration to feature testing and testing across platforms, have become much easier!

However, E2E testing still doesn't cover all cases, which is one of the downsides. While some functions like iOS streaming and remote testing are still manually performed, E2E now handles many of the previously repetitive tests (e.g., user registration, member addition, streaming, etc.), making development more streamlined.

Are you still manually repeating tests? It might be worthwhile to explore setting up an automated testing environment to improve testing efficiency!

Are you tired of connecting your android device every time? Then build your own DeviceFarm🏭.

ByoungWook Park — Fri, 28 Jul 2023 06:46:38 +0000

Are you developing a mobile app? If you're developing a mobile app, you're likely carrying an Android or iOS device and a USB cable.

Journey to install the app

To do Android testing, you will need a USB-C or USB-B cable compatible with your PC. And you need to set up USB Debugging on your Android device. And you need to connect your Android device to your PC. Now install the app with the adb install command.
What if I want to connect another device? You will need to purchase a new cable for the device and repeat the above process.
What if you change your seat? You should also carry your test device and cables with you.

Set it up once and always leave it ready.

The above USB connection is very cumbersome, but it is an unavoidable process to test the app before distributing it. You can't get rid of the above process, but what if you only do it at initial setup and make it ready?
In this case, you can use Device Farm.

If you use Cloud Device Farm

Currently, there are many Cloud Device Farms(Browserstack, Lambdatest, Perfecto, Headspin, testsigma). You can use Cloud Device Farm like this. However, this Cloud Device Farm is not suitable for this case.

If you do not want to expose your test app, there is a possibility that the app can be exposed if you install and test the app on the Cloud Device device.
If you don't want to spend a lot of money on testing, Cloud Device Farm can be expensive.
If you access the Cloud Device from a physically distant distance, there may be a latency in accessing the Cloud Device Farm and controlling the device.

Build your own Device Farm

Building DeviceFarm on-premise can solve the above problems.
Here's an open source project to build Device Farm on-premise. => Dogu

All devices are yours, so you don't have to worry about leaking test apps.
Building DeviceFarm via the Dogu Community version is free of charge.
Selenium, Appium integration is possible. You can test anytime, anywhere through devices connected to the device farm you built.

Why should game testing be automated?

ByoungWook Park — Thu, 18 May 2023 06:49:23 +0000

I had aspirations of becoming a game server developer, but to my surprise, I was assigned to a understaffed game platform team at my first job. That was the reality. It was there that I learned how to make games compatible with Android and iOS, and how to deploy and manage them.

Story

At first, learning new tasks was exciting. However, managing and maintaining project code to accommodate various operating systems and monitoring performance proved to be challenging. Every time we added new features, I had to write separate code and perform tests for both Android and iOS. Moreover, ensuring device compatibility posed an even more complex problem. We had to measure FPS and memory usage on various devices under the same conditions. Even though the game gained some popularity, developers, including myself, had to manually measure FPS and memory usage. This process seemed to take hours to complete. We had to build and install for game profiling, repeatedly measure under the same settings. What was even more unfortunate was that most game projects were large in scale, resulting in a significant amount of time spent on building and installation.

As time went on, I grew weary of this process. "Why am I the only one doing this task? Shouldn't the content developers be the ones measuring, considering they know what parts to measure and how?" I started to feel discontent and wondered about this. That's when a colleague, who was familiar with web and mobile development, introduced me to a tool called Appium. They suggested trying game test automation.

I was unaware of the existence of Appium and Selenium. Previously, I only knew about macro tools like AutoHotkey. However, I discovered that Appium and Selenium provided the ability to query and interact with UI based on XPath. When I first encountered this idea, I realized it could be applied to games as well. Fortunately, the game project had its own UI system, and each UI element had a unique identifier (ID). So, we added a TCP socket server to the game, used a Node.js client to send packets, and implemented the ability to query UI, click, and drag. Additionally, we added the functionality to execute interpretable scripts at runtime.

Results

The results were successful. The features we developed were suitable for mobile projects, allowing us to automatically perform multiple rounds of measurements for FPS, memory, and more on Android and iOS devices whenever new content was added. We no longer had to waste valuable time for developers and the quality assurance (QA) team. As a result, we could invest that saved time in other interesting tasks.

However, there was still a sense of regret. The reports of this system were scattered across various places. They were distributed across tools like Jenkins and Kibana, requiring us to find the button to start the tests and check the results in different locations. Moreover, we needed diverse information, but Kibana only provided charts to some extent.

Developing the automation system took a lot of time. While we completed core functionalities like game control, the need for reporting and device management arose, requiring additional development. However, there was a sense of dissatisfaction in proceeding. This automation system could only be applied to that specific project, making it difficult to apply to other projects. Furthermore, it couldn't solve problems that other game companies or projects might encounter. This led us to develop a solution that could be used across all companies.

That's why we developed Gamium and Dogu solutions. Gamium provides the ability to control games with scripts and, when connected to the Dogu solution, enables reporting and device management in the browser without space constraints. We no longer have to search or roam around to find devices that are causing issues.

Gamium

We have released Gamium as an open-source tool. It supports various game engines and client languages, hoping to solve repetitive and tedious tasks quickly in many projects.

Dogu Solution

If you're satisfied with applying Gamium, give the Dogu solution a try. Dogu solution allows you to remotely control devices within the organization, classify devices, and execute desired test scripts on specific devices. We are confident that this product can be of great help to projects.

DEV Community: Dogu Technologies

Dogu v2.0.0: Run routine with latest app, License policy and admin settings for self-hosted, Browser video recording, and more

✨ Run routine with latest app

✨ License policy and configuration for self-hosted

✨ Browser screen records in routine result report

✨ Host device with runner

Wrapped up

Dogu Technologies - Seamless Test Automation Platform

Dogu v1.11.0: Cross-browsing, Mobile app and Game test with Routine, Routine GUI editor, Dogu Studio live user session, and more

Dogu Technologies - Seamless Test Automation Platform

✨ Major updates in Routine

Support cross-browsing automation

Support mobile app test automation

Support game test automation

GUI Editor and Tutorial

✨ Dogu Studio live user session

Wrapped up

Dogu Technologies - Seamless Test Automation Platform

Dogu v1.10.0: Git integration with Bitbucket, CI integration with Jenkins plugin and GitHub Action, and more

dogu-team / dogu

The Unified Test Automation Platform

What's Dogu?

Architecture

Dogu Features

Device Farm

Device Studio

Inspecting UI

Test CI

Test Report

Start Dogu

With Self-Hosted

✨ Integration with Bitbucket

✨ Jenkins plugin and GitHub Action

jenkinsci / dogu-integration-plugin

Dogu Integration Plugin

Description

Features

Dogu Credential

Dogu Run Routine Build Step

How it works

Development

Getting Started

dogu-team / dogu-github-action

Dogu Github Action

Common Inputs

template

api-url (optional)

timeout (optional)

Templates

run_routine

Inputs

upload_application

Inputs

Env

DOGU_TOKEN

Example usage

✨ Project template for your products

Wrapped up

How Are E2E Tests Performed for Test Automation Product? - Dogu E2E Testing Implementation

dogu-team / dogu

Dogu is unified test automation platform for cross platform game and app

What's Dogu?

Architecture

Test CI Architecture

Dogu Features

Device Farm

Device Studio

Inspecting UI

Test CI

Test Report

TL;DR

Testing for Dogu

Challenges Faced...

Running Locally

Controlling Multiple Clients Simultaneously

Integration with CI

Writing Test Scripts

Happy Testing!

In Conclusion...

Are you tired of connecting your android device every time? Then build your own DeviceFarm🏭.

`template`

`api-url` (optional)

`timeout` (optional)

`run_routine`

`upload_application`

`DOGU_TOKEN`