did you have a webhook that triggered the verification of the pact, against your staging environment, and did your provider code publish the results back (against the correct version).
It looks like it didn't which is why you have no verification results.
For your consumer pact, which versions does it show it was verified against.

did you have a webhook that triggered the verification of the pact, against your staging environment, and did your provider code publish the results back (against the correct version).

Run pact-broker publish target/pacts \
Created analytics-video-data-service version 0f39a85ff606c83bc1be2909fb7852ec53d6b6d3 with branch RAD-41331-check-webhook-works and tags staging
Pact successfully published for analytics-video-data-service version 0f39a85ff606c83bc1be2909fb7852ec53d6b6d3 and provider participant-video-service.
  View the published pact at <https://usertesting.pactflow.io/pacts/provider/participant-video-service/consumer/analytics-video-data-service/version/0f39a85ff606c83bc1be2909fb7852ec53d6b6d3>
  Events detected: contract_published, contract_content_changed (first time any pact published for this consumer with consumer version tagged staging)
  No enabled webhooks found for the detected events

main

import { PactMessageProviderOptions } from '@pact-foundation/pact/src/dsl/options';

export const getPactBrokerToken = (): string => {
	const pactBrokerToken = process.env.PACT_BROKER_TOKEN;
	if (!pactBrokerToken) {
		throw new Error('PACT_BROKER_TOKEN must be present as an environment variable!');
	}
	return pactBrokerToken;
};

const pactServiceName = 'participant-video-service';
const providerVersion = process.env.VERSION || 'test';
const providerVersionBranch = process.env.BRANCH || 'local';
const publishVerificationResult = !!<http://process.env.CI|process.env.CI> || !!process.env.PACT_BROKER_PUBLISH_VERIFICATION_RESULTS;

export const getProviderOptions = (pactUrl?: string): Partial<PactMessageProviderOptions> => {
	const commonOptions: Partial<PactMessageProviderOptions> = {
		pactBrokerToken: getPactBrokerToken(),
		publishVerificationResult,
		providerVersion,
		providerVersionBranch,
	};

	// Triggered from a hook, minimal info needed
	// <https://docs.pact.io/provider/recommended_configuration#verification-triggered-by-a-contract-requiring-verification-published>
	if (pactUrl) {
		return {
			...commonOptions,
			pactUrls: [pactUrl],
		};
	}

	return {
		...commonOptions,
		provider: pactServiceName,
		enablePending: true,
		failIfNoPactsFound: false,
		consumerVersionSelectors: [
			{
			  environment: "staging", // Ensures verification happens against the consumer version in staging
			},
		  ],
	};
};

name: Pact - Contract Requiring Verification Published

on:
  repository_dispatch:
    types:
      - contract_requiring_verification_published
  workflow_dispatch:
    inputs:
      pact_url:
        type: string
        description: URL of pact to verify
        required: true
      environment:
        type: string
        description: provider version to use for the provider
        required: false

env:
  PACT_BROKER_TOKEN: ${{ secrets.PACT_BROKER_TOKEN }}
  PACT_BROKER_PUBLISH_VERIFICATION_RESULTS: true
  PACT_BROKER_BASE_URL: '<https://usertesting.pactflow.io>'
  VERSION: ${{ github.sha }}
  BRANCH: ${{ github.head_ref || github.ref_name }}

jobs:
  verify-pact-contract:
    permissions:
      contents: read
      packages: read
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
        with:
          ref: ${{github.event.client_payload.provider_sha || github.sha }}

      - uses: actions/setup-node@v3
        with:
          node-version: 20

      - name: Setup npm token
        run: npm config set "//npm.pkg.github.com/:_authToken=${{ secrets.GITHUB_TOKEN }}"

      - name: Install dependencies
        run: npm ci

      - name: Setting variables for the workflow when invoked by WebHook
        if: ${{ github.event_name == 'repository_dispatch' }}
        run: |
          echo "PACT_URL=${{ github.event.client_payload.pact_url }}" >> $GITHUB_ENV
          echo "BRANCH=${{ github.event.client_payload.consumer_branch }}" >> $GITHUB_ENV
          echo "VERSION=${{ github.event.client_payload.provider_sha || github.sha }}" >> $GITHUB_ENV
          echo "PROVIDER_VERSION=${{ github.event.client_payload.provider_version || github.sha }}" >> $GITHUB_ENV
          echo "ENVIRONMENT=${{ github.event.client_payload.environment || 'staging' }}" >> $GITHUB_ENV
          echo "Workflow triggered by the WebHook"

      - name: Setting variables for the workflow when invoked manually
        if: ${{ github.event_name == 'workflow_dispatch' }}
        run: |
          echo "PACT_URL=${{ inputs.pact_url }}" >> $GITHUB_ENV
          echo "BRANCH=${{ github.head_ref || github.ref_name }}" >> $GITHUB_ENV
          echo "VERSION=${{ env.VERSION }}" >> $GITHUB_ENV
          echo "ENVIRONMENT=${{ inputs.environment }}" >> $GITHUB_ENV
          echo "Workflow started manually"

      - name: Running contract verification
        run: npm run test:contract:provider --if-present
        env:
          PACT_URL: ${{ env.PACT_URL }}

a.

No enabled webhooks found for the detected events

- your webhook looks correctly setup for that consumer/provider pair. Does it need to be configured against a

team

so it is accessible to your integration?

team

I assume the webhook triggers manually, via test webhook button, and triggers a provider verification in github

main

name: Run Pact Contract tests
on:
  push:
    branches:
      - main
    paths:
      - "videoDataTracker/**"
  pull_request:
    types: [opened, synchronize, closed]
    branches:
      - main

env:
  sub_application_name: "videoDataTracker"
  pactfiles: "target/pacts"
  PACT_BROKER_BASE_URL: "<https://usertesting.pactflow.io>"
  PACT_BROKER_TOKEN: ${{ secrets.PACT_BROKER_TOKEN }}

jobs:
  run-contract-tests:
    runs-on: ubuntu-22.04
    steps:
    - name: Checkout
      uses: actions/checkout@v4
    - name: Set up JDK 21
      uses: actions/setup-java@v4
      with:
        java-version: '21'
        distribution: 'temurin'
    - name: Contract Test
      run: sbt -v clean +${{ env.sub_application_name }}/ContractTest/test
      env:
        GITHUB_TOKEN: "foobar"
        GH_ANALYTICS_PACKAGES_TOKEN: ${{ secrets.GA_READ }}
    - name: Upload pactfiles
      uses: actions/upload-artifact@v4
      with:
        name: Pactfiles
        path: ${{ env.pactfiles }}

  publish-pacts:
    needs: run-contract-tests
    runs-on: ubuntu-22.04
    steps:
    - name: Checkout
      uses: actions/checkout@v4
    - name: Download pactfiles
      uses: actions/download-artifact@v4
      with:
        name: Pactfiles
        path: ${{ env.pactfiles }}
    - name: Set up Ruby
      uses: ruby/setup-ruby@v1
      with:
        ruby-version: 3.1.2
    - name: Install pact_broker-client
      run: gem install pact_broker-client
    - name: Publish Pacts
      run: |
          pact-broker publish ${{ env.pactfiles }} \
            --auto-detect-version-properties \
            --broker-base-url ${{ env.PACT_BROKER_BASE_URL }} \
            --broker-token ${{ env.PACT_BROKER_TOKEN }}
  
    - name: Record Consumer Deployment to Staging
      run: |
          pact-broker record-deployment \
            --pacticipant=analytics-video-data-service \
            --version=${{ github.sha }} \
            --environment=staging \
            --broker-base-url=${{ env.PACT_BROKER_BASE_URL }} \
            --broker-token=${{ env.PACT_BROKER_TOKEN }}

pact-broker record-deployment

can-i-deploy

can-i-deploy

```When dry-run is enabled, always exit process with a success

code. Can also be enabled by setting the environment variable

PACT_BROKER_CAN_I_DEPLOY_DRY_RUN=true. This mode is useful when

setting up your CI/CD pipeline for the first time, or in a

'break glass' situation where you need to knowingly deploy what

Pact considers a breaking change. For the second scenario, it

is recommended to use the environment variable and just set it

for the build required to deploy that particular version, so

you don't accidentally leave the dry run mode enabled.```

• Secondly, once I see if the above working for

can-i-deploy

and successful, this PR will merge and the application set will be deployed to staging via argoCD. So I want to implement

record-deployment

in argoCD to record the latest version of the pact version for the given application set. To do this, I need the version which is on

main

for this pact and extract from argoCD, how can I extract this version from here? So that I can

record-deployment

as soon as the app is successfully deployed. Its the same way I want to do for PROD deployment also.

can-i-deploy

record-deployment

• Secondly, once I see if the above working for

can-i-deploy

and successful, this PR will merge and the application set will be deployed to staging via argoCD. So I want to implement

record-deployment

in argoCD to record the latest version of the pact version for the given application set. To do this, I need the version which is on

main

for this pact and extract from argoCD, how can I extract this version from here? So that I can

record-deployment

as soon as the app is successfully deployed. Its the same way I want to do for PROD deployment also.

main