Project Dashboard

The Project Dashboard is your central hub for managing all aspects of your testing project. It provides comprehensive information about your application under test, build details, team members, CI settings, and more.

🏗️ Build Management

Manage Your App Builds

• Upload new builds

• View build information

• Compare versions

• Track build history

👥 Team Collaboration

Work With Your Team

• Add team members

• Manage permissions

• Share resources

• Track activity

⚙️ Project Settings

Configure Your Project

• Set up notifications

• Configure integrations

• Manage access controls

• Customize workflows

Dashboard Sections Overview

The Project Dashboard consists of 5 main sections designed to streamline your testing workflow:

📱 Builds👥 Team🔄 Remote Upload⚙️ Settings🔗 Groups

Application Build Management

Manage application builds and versions with complete visibility into your app’s evolution.

• Build Uploads: Upload new builds manually or via API

• Version Control: Track different versions and builds

• Build Information: View comprehensive build metadata

• Build Actions: Download, share, or delete builds

Builds Section

This is the default landing section when you access a project, providing comprehensive build management capabilities.

📊 Build Information Display

What You’ll See:

• Build Details: Name, version, and package information

• Technical Info: Version code and launch activity

• Metadata: Description, file size, and upload details

• History: Uploader name and upload timestamp

🎯 Key Benefits

Why It Matters:

• Version Control: Track different app versions

• Team Visibility: See who uploaded what and when

• Build Selection: Easy switching between builds

• Metadata Management: Rich build information storage

Build Information Display

The Builds section displays comprehensive information for each build in your project:

📱 Build Details📋 Build Metadata🔄 Build Status

Core Build Information

• Build Name: Descriptive name for easy identification

• Version Information: Version name and code

• Package Details: Application package name and structure

• Launch Activity: Primary activity that starts the app

Tip

Best Practice: Use descriptive build names that include version numbers and build types (e.g., “MyApp_v2.1.0_Release”)

Multiple Build Management

You can upload and manage multiple builds within a single project for comprehensive version testing:

📚 Build Organization

Multiple Build Benefits:

• Version Comparison: Test different versions side-by-side

• Regression Testing: Compare new builds against previous versions

• A/B Testing: Test different build variants

• Release Management: Maintain stable and development builds

🔄 Build Selection

Easy Build Switching:

• Build Dropdown: Use the Build dropdown to select which build to test

• Quick Access: Switch between builds without re-uploading

• Context Preservation: Maintain test configurations across builds

• Team Coordination: All team members see the same build options

Available Actions

The Builds section provides several management options to streamline your workflow:

📤 Upload New Build

Manual Build Upload

Manually upload an application build from your local system

• Supported Formats: APK, IPA, ZIP files

• Build Validation: Automatic validation during upload

• Metadata Entry: Add descriptions and labels

• Team Notification: Notify team members of new builds

🔗 Get Build URL

Build URL Access

Copy the download URL for the currently selected build to your clipboard

• Direct Download: Share build links with team members

• External Access: Access builds from external tools

• Version Control: Maintain links to specific build versions

• Backup Access: Alternative access method for builds

🆔 Copy Build ID

Build Identification

Copy the unique build identifier to your clipboard

• API Integration: Use build IDs in API calls

• Automation: Reference builds in automated scripts

• Tracking: Unique identifier for each build

• CI/CD Integration: Connect with continuous integration

🗑️ Delete Selected Build

Build Cleanup

Remove the selected build from the project (admin privileges required)

• Storage Management: Free up storage space

• Project Cleanup: Remove outdated builds

• Admin Control: Restricted to project administrators

• Safety Check: Confirmation required before deletion

Warning

Admin Privileges Required: Only project members with admin privileges can delete builds from the project. This prevents accidental deletion of important builds.

Tip

Build Management Best Practices:

• Regular Cleanup: Periodically remove old builds to save storage

• Descriptive Names: Use clear, descriptive build names

• Version Control: Maintain a logical versioning scheme

• Team Communication: Notify team members about significant builds

Team Management

The Team section displays all project members and manages access permissions, enabling effective collaboration across your testing team.

👥 Team Collaboration

What Team Members Can Do:

• Build Access: Test any build within the project

• Automation: Create and run automation scripts

• Reports: View and generate comprehensive test reports

• Collaboration: Work together on test case development

🔐 Access Control

Permission Management:

• Role-Based Access: Admin and regular member roles

• Granular Permissions: Control what each member can do

• Security: Prevent unauthorized changes

• Audit Trail: Track member activities

Team Member Capabilities

All project members have access to core testing functionality:

🧪 Testing Capabilities🤖 Automation Features📊 Reporting & Analytics🤝 Collaboration Tools

Core Testing Functions

• Build Testing: Test any build within the project

• Device Access: Use project devices for testing

• Session Management: Create and manage test sessions

• Data Collection: Capture screenshots, videos, and logs

Tip

Collaboration: Team members can see each other’s test sessions and results for better coordination

Member Roles and Permissions

Projects support two types of members with different privilege levels:

👑 Admin Members👤 Regular Members

Enhanced Privileges

Admin members have comprehensive project management capabilities:

🛠️ Project Management

Administrative Powers:

• Build Management: Delete builds from the project

• Team Control: Add or remove team members

• Permission Management: Grant or revoke admin privileges

• Project Settings: Configure project preferences

🔧 Technical Access

Advanced Features:

• API Access: Execute CURL commands for remote build uploads

• Integration Setup: Configure external tool integrations

• Advanced Settings: Access all project configuration options

• Audit Controls: View detailed audit logs and activity

🔑 Automatic Admin Rights

Project Creator Privileges

The project creator automatically receives admin privileges and has full control over the project.

This includes:

• Full administrative access

• Ability to grant admin rights to others

• Complete project control

• Cannot have admin rights revoked

⚖️ Admin Types Explained

Project Admin vs. RobusTest Admin

Project Admin: Limited to their specific project RobusTest Admin: Platform-wide administrative access

Key Difference:

• Project Admins: Single project scope

• RobusTest Admins: Cross-project access

🔒 Security Best Practices

Team Management Tips:

• Principle of Least Privilege: Grant minimum necessary permissions

• Regular Reviews: Periodically review team member access

• Admin Assignments: Carefully consider who gets admin privileges

• Activity Monitoring: Monitor team member activities for security

Remote Build Upload (API)

Note

Admin Only: This section is only visible to project admin members for security reasons.

The Remote Build Upload section provides powerful API capabilities for automating build uploads to your project, enabling seamless CI/CD integration.

🔄 CI/CD Integration

Automated Build Pipeline

• Continuous Integration: Automatically upload builds from CI systems

• Build Automation: Trigger uploads after successful builds

• Pipeline Integration: Connect with Jenkins, GitLab CI, GitHub Actions

• Workflow Automation: Reduce manual upload steps

🚀 Key Benefits

Why Use API Upload

• Time Savings: Eliminate manual upload steps

• Consistency: Ensure all builds follow the same process

• Reliability: Reduce human error in build management

• Scalability: Handle multiple projects and builds efficiently

API Command Structure

The Remote Build Upload uses a standardized CURL command format:

curl -X PUT '<RobusTest URL>/v3/project/<PROJECT IDENTIFIER>/build?accesskey=<USER ACCESS KEY>' \
     -H 'content-Type: multipart/form-data' \
     -F 'build=@<BUILD NAME WITH PATH>' \
     -F 'buildInfo={"desc":"<build description>", "label":"<label>","activityClass":"<launch activity>"}'

Command Parameters Explained

Let’s break down each component of the API command:

🌐 RobusTest URL🆔 Project Identifier🔑 User Access Key📁 Build Path📋 Build Metadata

Platform Access URL

The URL that you use to access the RobusTest platform

Format Examples:

• IP-based: http://192.168.1.100:8085

• Domain-based: http://robustest.company.com:8085

• Secure: https://robustest.company.com

Tip

Finding Your URL: Use the same URL you access RobusTest from your browser

Sample Implementation

Here’s a complete example of the remote build upload command:

curl -X PUT 'http://robustest.company.com:8085/v3/project/5d176ffef0238be8f3b7afa5/build?accesskey=aY33cDmkt7B2nAjxBl6Tp2FWv4' \
     -H 'content-Type: multipart/form-data' \
     -F 'build=@/builds/myapp-v1.2.3.apk' \
     -F 'buildInfo={"desc":"Release build v1.2.3 with bug fixes", "label":"v1.2.3"}'

CI/CD Integration Examples

🔧 Jenkins Integration🐙 GitHub Actions🦊 GitLab CI🔄 Generic Script

Jenkins Pipeline Example

pipeline {
    agent any
    stages {
        stage('Build') {
            steps {
                // Your build steps here
                sh './gradlew assembleRelease'
            }
        }
        stage('Upload to RobusTest') {
            steps {
                script {
                    def buildPath = "app/build/outputs/apk/release/app-release.apk"
                    def buildInfo = """{"desc":"Jenkins build ${BUILD_NUMBER}", "label":"${BUILD_TAG}"}"""

                    sh """
                        curl -X PUT '${ROBUSTEST_URL}/v3/project/${PROJECT_ID}/build?accesskey=${ACCESS_KEY}' \
                             -H 'content-Type: multipart/form-data' \
                             -F 'build=@${buildPath}' \
                             -F 'buildInfo=${buildInfo}'
                    """
                }
            }
        }
    }
}

Best Practices

🔒 Security Best Practices

Protect Your Credentials

• Environment Variables: Store access keys in environment variables

• Secret Management: Use CI/CD secret management systems

• Key Rotation: Regularly rotate access keys

• Access Control: Limit who has access to API keys

Warning

Never commit access keys to version control

🚀 Automation Best Practices

Optimize Your Workflow

• Build Validation: Verify build success before upload

• Error Handling: Implement proper error handling

• Notifications: Set up notifications for upload status

• Metadata: Include meaningful build descriptions

Tip

Test Automation: Trigger automated tests after successful uploads

4. Settings

This section provides you the following options:

a. Enable notifications - On enabling this checkbox, each member of the team is notified whenever a new build is uploaded to the project

b. Choose Bug Tracker configuration - RobusTest supports Continuous Integration with your existing CI tools through APIs.

Once you have integrated your Bug Tracker tool wih RobusTest, this configuration will be available for selection in the ‘Bug Tracker’ drop down. Once the required configuration is selected, all bugs encountered during your testing can be logged directly, from RobusTest, into the tool of your choice.

You can configure your project with the tool of your choice through the ‘Integration’ section of the RobusTest Admin Console.