{
  "consumer": {
    "name": "service-consumer"
  },
  "interactions": [
    {
      "contents": {
        "content": "CAEQAQ==",
        "contentType": "application/protobuf;message=.protobuf.order_data.Order",
        "contentTypeHint": "BINARY",
        "encoded": "base64"
      },
      "description": "async: order via kafka",
      "interactionMarkup": {
        "markup": "```protobuf\nmessage Order {\n    int32 id = 1;\n    enum .protobuf.order_data.Order.OrderStatus status = 2;\n}\n```\n",
        "markupType": "COMMON_MARK"
      },
      "matchingRules": {
        "body": {
          "$.id": {
            "combine": "AND",
            "matchers": [
              {
                "match": "integer"
              }
            ]
          },
          "$.status": {
            "combine": "AND",
            "matchers": [
              {
                "match": "regex",
                "regex": "(?-mix:(PENDING|COMPLETED|CANCELED))"
              }
            ]
          }
        },
        "metadata": {
          "key": {
            "combine": "AND",
            "matchers": [
              {
                "match": "regex",
                "regex": "(?-mix:.*)"
              }
            ]
          },
          "topic": {
            "combine": "AND",
            "matchers": [
              {
                "match": "regex",
                "regex": "(?-mix:.*)"
              }
            ]
          }
        }
      },
      "metadata": {
        "contentType": "application/protobuf;message=.protobuf.order_data.Order",
        "key": "key",
        "topic": "orders-topic"
      },
      "pending": false,
      "pluginConfiguration": {
        "protobuf": {
          "descriptorKey": "2a5b88336a6f5a708460709e23f3c701",
          "message": ".protobuf.order_data.Order"
        }
      },
      "providerStates": [
        {
          "name": "order exists",
          "params": {
            "contentType": "application/protobuf;message=.protobuf.order_data.Order",
            "order_id": 1
          }
        }
      ],
      "type": "Asynchronous/Messages"
    },
    {
      "description": "grpc: fetch order via grpc",
      "interactionMarkup": {
        "markup": "```protobuf\nmessage OrderStatusResponse {\n    message .orders.Order order = 1;\n}\n```\n",
        "markupType": "COMMON_MARK"
      },
      "pending": false,
      "pluginConfiguration": {
        "protobuf": {
          "descriptorKey": "5a39c2b98badf0e1d0ed2e038cba0d62",
          "service": ".orders.Orders/StatusById"
        }
      },
      "providerStates": [
        {
          "name": "order exists",
          "params": {
            "order_id": 1
          }
        }
      ],
      "request": {
        "contents": {
          "content": "CAE=",
          "contentType": "application/protobuf;message=.orders.OrderStatusRequest",
          "contentTypeHint": "BINARY",
          "encoded": "base64"
        },
        "matchingRules": {
          "body": {
            "$.id": {
              "combine": "AND",
              "matchers": [
                {
                  "match": "integer"
                }
              ]
            }
          }
        },
        "metadata": {
          "contentType": "application/protobuf;message=.orders.OrderStatusRequest"
        }
      },
      "response": [
        {
          "contents": {
            "content": "CgQIChAD",
            "contentType": "application/protobuf;message=.orders.OrderStatusResponse",
            "contentTypeHint": "BINARY",
            "encoded": "base64"
          },
          "matchingRules": {
            "body": {
              "$.order.id": {
                "combine": "AND",
                "matchers": [
                  {
                    "match": "integer"
                  }
                ]
              },
              "$.order.status": {
                "combine": "AND",
                "matchers": [
                  {
                    "match": "equality"
                  }
                ]
              }
            }
          },
          "metadata": {
            "contentType": "application/protobuf;message=.orders.OrderStatusResponse"
          }
        }
      ],
      "transport": "grpc",
      "type": "Synchronous/Messages"
    },
    {
      "description": "http: fetch order via http",
      "pending": false,
      "providerStates": [
        {
          "name": "order exists",
          "params": {
            "order_id": 1
          }
        }
      ],
      "request": {
        "method": "GET",
        "path": "/api/v1/orders/1"
      },
      "response": {
        "body": {
          "content": {
            "id": 1,
            "status": "COMPLETED"
          },
          "contentType": "application/json",
          "encoded": false
        },
        "headers": {
          "Content-Type": [
            "application/json"
          ]
        },
        "matchingRules": {
          "body": {
            "$.id": {
              "combine": "AND",
              "matchers": [
                {
                  "match": "integer"
                }
              ]
            },
            "$.status": {
              "combine": "AND",
              "matchers": [
                {
                  "match": "regex",
                  "regex": "(?-mix:(PENDING|COMPLETED|CANCELED))"
                }
              ]
            }
          }
        },
        "status": 200
      },
      "transport": "http",
      "type": "Synchronous/HTTP"
    }
  ],
  "metadata": {
    "pactRust": {
      "ffi": "0.4.22",
      "mockserver": "1.2.9",
      "models": "1.2.3"
    },
    "pactSpecification": {
      "version": "4.0"
    },
    "plugins": [
      {
        "configuration": {
          "2a5b88336a6f5a708460709e23f3c701": {
            "protoDescriptors": "Cr0BCgtvcmRlci5wcm90bxITcHJvdG9idWYub3JkZXJfZGF0YSKQAQoFT3JkZXISDgoCaWQYASABKAVSAmlkEj4KBnN0YXR1cxgCIAEoDjImLnByb3RvYnVmLm9yZGVyX2RhdGEuT3JkZXIuT3JkZXJTdGF0dXNSBnN0YXR1cyI3CgtPcmRlclN0YXR1cxILCgdQRU5ESU5HEAASDQoJQ09NUExFVEVEEAESDAoIQ0FOQ0VMRUQQAmIGcHJvdG8z",
            "protoFile": "syntax = \"proto3\";\n\npackage protobuf.order_data;\n\nmessage Order {\n  enum OrderStatus {\n    PENDING = 0;\n    COMPLETED = 1;\n    CANCELED = 2;\n  }\n\n  int32 id = 1;\n  OrderStatus status = 2;\n}\n"
          },
          "5a39c2b98badf0e1d0ed2e038cba0d62": {
            "protoDescriptors": "Cu0CCgxvcmRlcnMucHJvdG8SBm9yZGVycyKIAQoFT3JkZXISDgoCaWQYASABKAVSAmlkEiwKBnN0YXR1cxgCIAEoDjIULm9yZGVycy5PcmRlci5TdGF0dXNSBnN0YXR1cyJBCgZTdGF0dXMSCwoHUEVORElORxAAEg0KCUNPTVBMRVRFRBABEgwKCENBTkNFTEVEEAISDQoJUFJPQ0VTU0VEEAMiJAoST3JkZXJTdGF0dXNSZXF1ZXN0Eg4KAmlkGAEgASgFUgJpZCI6ChNPcmRlclN0YXR1c1Jlc3BvbnNlEiMKBW9yZGVyGAEgASgLMg0ub3JkZXJzLk9yZGVyUgVvcmRlcjJPCgZPcmRlcnMSRQoKU3RhdHVzQnlJZBIaLm9yZGVycy5PcmRlclN0YXR1c1JlcXVlc3QaGy5vcmRlcnMuT3JkZXJTdGF0dXNSZXNwb25zZUIP6gIMR3JwYzo6T3JkZXJzYgZwcm90bzM=",
            "protoFile": "syntax = \"proto3\";\n\npackage orders;\noption ruby_package = \"Grpc::Orders\";\n\nservice Orders {\n  rpc StatusById(OrderStatusRequest) returns (OrderStatusResponse);\n}\n\nmessage Order {\n int32 id = 1;\n enum Status {\n    PENDING = 0;\n    COMPLETED = 1;\n    CANCELED = 2;\n    PROCESSED = 3;\n }\n Status status = 2;\n}\n\nmessage OrderStatusRequest {\n int32 id = 1;\n}\n\nmessage OrderStatusResponse {\n Order order = 1;\n}\n"
          }
        },
        "name": "protobuf",
        "version": "0.5.1"
      }
    ],
    "sbmt-pact": {
      "pact-ffi": "0.4.22"
    }
  },
  "provider": {
    "name": "service-provider"
  }
}

RSpec.describe "Http::Orders", :pact do  
  # декларируем тип взаимодействия
  has_http_pact_between "service-consumer", "service-provider"
  
  let(:order_id) { 1 }  
  
  let(:client) { Http::Orders::V1::Client.new }  
  let(:make_request) { client.order_status(id: order_id) }  

  # определяем заимодействие между сервисами и матчеры запроса/ответа
  let(:interaction) do  
    new_interaction
    # определяем provider state с необходимыми метаданными
    # которые можно будет использовать позже, в момент запуска провайдер-теста
    .given("order exists", order_id: order_id)  
    .upon_receiving("fetch order via http")
    # описываем формат запроса
    .with_request(:get, "/api/v1/orders/#{order_id}")  
    # и формат ответа
    .with_response(200, headers: {}, body: {
        id: match_any_integer,
        status: match_regex(/(PENDING|COMPLETED|CANCELED|PROCESSED)/, "COMPLETED")
    })
  end  
  
  it "executes the pact test without errors" do
    # запускаем тест, в этот момент pact-core поднимает mock-сервер,
    # а наш http-клиент делает реальный запрос в данный мок
    interaction.execute do
        # в примере нам важен только критерий успешности запроса,
        # форматы проверяются под капотом pact-core
        expect(make_request).to be_success  
    end
    # по результатам будет сгенерирован (локально) pact-манифест
  end
end

{
  "consumer": {
    "name": "service-consumer"
  },
  "interactions": [
    {
      "description": "http: fetch order via http",
      "pending": false,
      "providerStates": [
        {
          "name": "order exists",
          "params": {
            "order_id": 1
          }
        }
      ],
      "request": {
        "method": "GET",
        "path": "/api/v1/orders/1"
      },
      "response": {
        "body": {
          "content": {
            "id": 1,
            "status": "COMPLETED"
          },
          "contentType": "application/json",
          "encoded": false
        },
        "headers": {
          "Content-Type": [
            "application/json"
          ]
        },
        "matchingRules": {
          "body": {
            "$.id": {
              "combine": "AND",
              "matchers": [
                {
                  "match": "integer"
                }
              ]
            },
            "$.status": {
              "combine": "AND",
              "matchers": [
                {
                  "match": "regex",
                  "regex": "(?-mix:(PENDING|COMPLETED|CANCELED))"
                }
              ]
            }
          }
        },
        "status": 200
      },
      "transport": "http",
      "type": "Synchronous/HTTP"
    }
  ],
  "metadata": {
    "pactRust": {
      "ffi": "0.4.22",
      "mockserver": "1.2.9",
      "models": "1.2.3"
    },
    "pactSpecification": {
      "version": "4.0"
    },
    "sbmt-pact": {
      "pact-ffi": "0.4.22"
    }
  },
  "provider": {
    "name": "service-provider"
  }
}

RSpec.describe "Orders::Http", :pact do
  # аналогично - декларируем тип взаимодействия и название провайдера
  # тут указывать консюмер уже не нужно: все консюмеры определяются в рантайме,
  # по запросу в pact-брокер
  http_pact_provider "service-provider"

  # наш provider-state
  provider_state 'order exists' do  
	set_up do |params|
	  # для которого необходимо в БД предсоздать сущность
	  # заказа с ID, который берем из метаданных
	  FactoryBot.create(:order, id: params['order_id'])  
	end  
  end

  # под капотом будет поднят http-сервер провайдера
  # в который pact-core mock-client сделает запрос, 
  # описанный в pact-манифесте
end

syntax = "proto3";  
  
package orders;  
  
service Orders {  
 rpc StatusById(OrderStatusRequest) returns (OrderStatusResponse);  
}  
  
message Order {  
 int32 id = 1;  
 enum Status {  
    PENDING = 0;  
    COMPLETED = 1;  
    CANCELED = 2;  
    PROCESSED = 3;  
 }  
 Status status = 3;  
}  
  
message OrderStatusRequest {  
 int32 id = 1;  
}  
  
message OrderStatusResponse {  
 Order order = 1;  
}

RSpec.describe "Grpc::Orders", :pact do  
  # декларируем тип взаимодействия
  has_grpc_pact_between "service-consumer", "service-provider"
  
  let(:order_id) { 1 }  
  
  let(:client) { Grpc::Orders::V1::Client.new }  
  let(:make_request) { client.order_status_by_id(id: order_id) }  

  # определяем заимодействие между сервисами и матчеры запроса/ответа
  let(:interaction) do
    new_interaction
      # указываем proto-файл и название тестируемого rpc-сервиса
      .with_service("deps/services/orders.proto", "Orders/StatusById")
      .upon_receiving("fetch order via grpc")
      # определяем provider state с необходимыми метаданными
      # которые можно будет использовать позже, в момент запуска провайдер-теста
      .given("order exists", order_id: order_id)  
  	  # описываем формат данных с матчерами
      .with_request(id: match_any_integer(order_id))
      .with_response(
        order: {
          id: match_any_integer,
          status: match_exactly("PROCESSED")
        }
      )
  end
  
  it "executes the pact test without errors" do
    # запускаем тест, в этот момент pact-core поднимает mock-сервер,
    # а наш grpc-клиент делает реальный запрос в данный мок
    interaction.execute do
        # в примере нам важен только критерий успешности запроса,
        # форматы проверяются под капотом pact-core
        expect(make_request).to be_success  
    end
    # по результатам будет сгенерирован (локально) pact-манифест
  end
end

RSpec.describe "Orders::Grpc", :pact do
  # аналогично - декларируем тип взаимодействия и название провайдера
  # тут указывать консюмер уже не нужно: все консюмеры определяются в рантайме,
  # по запросу в pact-брокер
  grpc_pact_provider "service-provider"

  # определяем provider-state
  provider_state 'order exists' do  
	set_up do |params|
	  # для которого нам нужно в БД предсоздать сущность
	  # заказа с ID, который берем из метаданных
	  FactoryBot.create(:order, id: params['order_id'])  
	end  
  end

  # под капотом будет поднят grpc-сервер провайдера
  # в который pact-core mock-client сделает запрос, 
  # описанный в pact-манифесте
end

{
  "consumer": {
    "name": "service-consumer"
  },
  "interactions": [
    {
      "description": "grpc: fetch order via grpc",
      "interactionMarkup": {
        "markup": "```protobuf\nmessage OrderStatusResponse {\n    message .orders.Order order = 1;\n}\n```\n",
        "markupType": "COMMON_MARK"
      },
      "pending": false,
      "pluginConfiguration": {
        "protobuf": {
          "descriptorKey": "5a39c2b98badf0e1d0ed2e038cba0d62",
          "service": ".orders.Orders/StatusById"
        }
      },
      "providerStates": [
        {
          "name": "order exists",
          "params": {
            "order_id": 1
          }
        }
      ],
      "request": {
        "contents": {
          "content": "CAE=",
          "contentType": "application/protobuf;message=.orders.OrderStatusRequest",
          "contentTypeHint": "BINARY",
          "encoded": "base64"
        },
        "matchingRules": {
          "body": {
            "$.id": {
              "combine": "AND",
              "matchers": [
                {
                  "match": "integer"
                }
              ]
            }
          }
        },
        "metadata": {
          "contentType": "application/protobuf;message=.orders.OrderStatusRequest"
        }
      },
      "response": [
        {
          "contents": {
            "content": "CgQIChAD",
            "contentType": "application/protobuf;message=.orders.OrderStatusResponse",
            "contentTypeHint": "BINARY",
            "encoded": "base64"
          },
          "matchingRules": {
            "body": {
              "$.order.id": {
                "combine": "AND",
                "matchers": [
                  {
                    "match": "integer"
                  }
                ]
              },
              "$.order.status": {
                "combine": "AND",
                "matchers": [
                  {
                    "match": "equality"
                  }
                ]
              }
            }
          },
          "metadata": {
            "contentType": "application/protobuf;message=.orders.OrderStatusResponse"
          }
        }
      ],
      "transport": "grpc",
      "type": "Synchronous/Messages"
    }
  ],
  "metadata": {
    "pactRust": {
      "ffi": "0.4.22",
      "mockserver": "1.2.9",
      "models": "1.2.3"
    },
    "pactSpecification": {
      "version": "4.0"
    },
    "plugins": [
      {
        "configuration": {
          "5a39c2b98badf0e1d0ed2e038cba0d62": {
            "protoDescriptors": "Cu0CCgxvcmRlcnMucHJvdG8SBm9yZGVycyKIAQoFT3JkZXISDgoCaWQYASABKAVSAmlkEiwKBnN0YXR1cxgCIAEoDjIULm9yZGVycy5PcmRlci5TdGF0dXNSBnN0YXR1cyJBCgZTdGF0dXMSCwoHUEVORElORxAAEg0KCUNPTVBMRVRFRBABEgwKCENBTkNFTEVEEAISDQoJUFJPQ0VTU0VEEAMiJAoST3JkZXJTdGF0dXNSZXF1ZXN0Eg4KAmlkGAEgASgFUgJpZCI6ChNPcmRlclN0YXR1c1Jlc3BvbnNlEiMKBW9yZGVyGAEgASgLMg0ub3JkZXJzLk9yZGVyUgVvcmRlcjJPCgZPcmRlcnMSRQoKU3RhdHVzQnlJZBIaLm9yZGVycy5PcmRlclN0YXR1c1JlcXVlc3QaGy5vcmRlcnMuT3JkZXJTdGF0dXNSZXNwb25zZUIP6gIMR3JwYzo6T3JkZXJzYgZwcm90bzM=",
            "protoFile": "syntax = \"proto3\";\n\npackage orders;\noption ruby_package = \"Grpc::Orders\";\n\nservice Orders {\n  rpc StatusById(OrderStatusRequest) returns (OrderStatusResponse);\n}\n\nmessage Order {\n int32 id = 1;\n enum Status {\n    PENDING = 0;\n    COMPLETED = 1;\n    CANCELED = 2;\n    PROCESSED = 3;\n }\n Status status = 2;\n}\n\nmessage OrderStatusRequest {\n int32 id = 1;\n}\n\nmessage OrderStatusResponse {\n Order order = 1;\n}\n"
          }
        },
        "name": "protobuf",
        "version": "0.5.1"
      }
    ],
    "sbmt-pact": {
      "pact-ffi": "0.4.22"
    }
  },
  "provider": {
    "name": "service-provider"
  }
}

RSpec.describe "Consumer::Orders", :pact do  
  # декларируем тип взаимодействия
  has_message_pact_between "service-consumer", "service-provider"

  let(:deserializer) do  
	Sbmt::KafkaConsumer::Serialization::ProtobufDeserializer.new(  
	  # где Protobuf::Order - сгенерированный руби-класс
	  # на основе orders.proto
	  message_decoder_klass: "Protobuf::Order"
	)  
  end

  let(:consumer) { build_consumer(OrdersConsumer.consumer_klass.new) }
  let(:order_id) { 123 }
  
  # определяем заимодействие между сервисами и матчеры запроса/ответа
  let(:interaction) do
    new_interaction
      # указываем proto-файл и название data-класса (message)
      .with_proto_class("deps/services/orders.proto", "Order")
      # определяем provider state с необходимыми метаданными
      # которые можно будет использовать позже, в момент запуска провайдер-теста
      .given("order exists", order_id: order_id)  
      .upon_receiving("order via kafka")
  	  # описываем формат данных с матчерами
      .with_proto_contents(
        id: match_any_integer(order_id),
        status: match_regex(/(PENDING|COMPLETED|CANCELED)/, "COMPLETED")
      )
      # описываем метаданные: топик и ключ партиционирования
      .with_metadata(
        topic: match_exactly("orders-topic"),
        key: match_any_string
      )
  end
  
  it "executes the pact test without errors" do
    # запускаем тест, в этот момент под капотом конфигурируется pact-core,
    # который в параметрах блока вернет уже провалидированные payload
    # и метаданные, которые мы задали в interaction
	interaction.execute do |proto_payload, meta|  
	    # "публикуем" сообщение в кафку с помощью testing-инструментов
	    # sbmt-kafka_consumer (взаимодействия с реальным кафка-брокером нет)
		publish_to_sbmt_karafka(  
		    proto_payload, deserializer: deserializer,  
		    topic: meta["topic"], key: meta["key"]
		)

		# простой expectation для демонстрации консюминга
		expect(Rails.logger).to receive(:info).with(/Processing message/)

		# консюмим опубликованное сообщение с помощью testing-инструментов
		# гема sbmt-kafka_consumer - вызывается класс консюмера,
		# определенный выше
		consume_with_sbmt_karafka
	end
	# по результатам будет сгенерирован (локально) pact-манифест
  end
end

RSpec.describe "Consumers::Kafka", :pact do
  # аналогично - декларируем тип взаимодействия и название провайдера
  # тут указывать консюмер уже не нужно: все консюмеры определяются в рантайме,
  # по запросу в pact-брокер
  message_pact_provider "service-provider"  

  handle_message "order via kafka" do |provider_state|  
    # получаем метаданные из provider state
    # и создаем в БД заказ с нужным ID
	order_id = provider_state.dig("params", "order_id")  
	order = FactoryBot.create(:order, id: order_id)

	# это специальный хелпер, позволяющий запродюсить событие
	# в mock-message-server, тем самым взаимодействуя с pact-core,
	# где будет производиться матчинг формата пейлоада
	with_pact_producer do |client|
		# client - мок-клиент sbmt-kafka_producer
		OrderProducer.new(client: client).publish(order)  
	end  
  end
end

{
  "consumer": {
    "name": "service-consumer"
  },
  "interactions": [
    {
      "contents": {
        "content": "CAEQAQ==",
        "contentType": "application/protobuf;message=.protobuf.order_data.Order",
        "contentTypeHint": "BINARY",
        "encoded": "base64"
      },
      "description": "async: order via kafka",
      "interactionMarkup": {
        "markup": "```protobuf\nmessage Order {\n    int32 id = 1;\n    enum .protobuf.order_data.Order.OrderStatus status = 2;\n}\n```\n",
        "markupType": "COMMON_MARK"
      },
      "matchingRules": {
        "body": {
          "$.id": {
            "combine": "AND",
            "matchers": [
              {
                "match": "integer"
              }
            ]
          },
          "$.status": {
            "combine": "AND",
            "matchers": [
              {
                "match": "regex",
                "regex": "(?-mix:(PENDING|COMPLETED|CANCELED))"
              }
            ]
          }
        },
        "metadata": {
          "key": {
            "combine": "AND",
            "matchers": [
              {
                "match": "regex",
                "regex": "(?-mix:.*)"
              }
            ]
          },
          "topic": {
            "combine": "AND",
            "matchers": [
              {
                "match": "equality"
              }
            ]
          }
        }
      },
      "metadata": {
        "contentType": "application/protobuf;message=.protobuf.order_data.Order",
        "key": "any",
        "topic": "orders-topic"
      },
      "pending": false,
      "pluginConfiguration": {
        "protobuf": {
          "descriptorKey": "2a5b88336a6f5a708460709e23f3c701",
          "message": ".protobuf.order_data.Order"
        }
      },
      "providerStates": [
        {
          "name": "order exists",
          "params": {
            "contentType": "application/protobuf;message=.protobuf.order_data.Order",
            "order_id": 1
          }
        }
      ],
      "type": "Asynchronous/Messages"
    }
  ],
  "metadata": {
    "pactRust": {
      "ffi": "0.4.22",
      "models": "1.2.3"
    },
    "pactSpecification": {
      "version": "4.0"
    },
    "plugins": [
      {
        "configuration": {
          "2a5b88336a6f5a708460709e23f3c701": {
            "protoDescriptors": "Cr0BCgtvcmRlci5wcm90bxITcHJvdG9idWYub3JkZXJfZGF0YSKQAQoFT3JkZXISDgoCaWQYASABKAVSAmlkEj4KBnN0YXR1cxgCIAEoDjImLnByb3RvYnVmLm9yZGVyX2RhdGEuT3JkZXIuT3JkZXJTdGF0dXNSBnN0YXR1cyI3CgtPcmRlclN0YXR1cxILCgdQRU5ESU5HEAASDQoJQ09NUExFVEVEEAESDAoIQ0FOQ0VMRUQQAmIGcHJvdG8z",
            "protoFile": "syntax = \"proto3\";\n\npackage protobuf.order_data;\n\nmessage Order {\n  enum OrderStatus {\n    PENDING = 0;\n    COMPLETED = 1;\n    CANCELED = 2;\n  }\n\n  int32 id = 1;\n  OrderStatus status = 2;\n}\n"
          }
        },
        "name": "protobuf",
        "version": "0.5.1"
      }
    ],
    "sbmt-pact": {
      "pact-ffi": "0.4.22"
    }
  },
  "provider": {
    "name": "service-provider"
  }
}