Beyond Cypress `Cy.Intercept`: آزمایش پرداخت وب سایت در زمان واقعی در چارچوب های ترکیبی سرو

Cypress.Commands.add(
  "connectWStoListen",
  (url, { onBalanceUpdate, onPaymentStatusUpdate }) => {
    return new Promise((resolve, reject) => {
      const ws = new WebSocket(url);
      Cypress.env("currentWebSocket", ws); // Store WebSocket instance globally
...

...     
      const handshakeData="{"protocol":"json","version":1}\x1e";
      let receivedEmptyResponse = false; // Track server's empty {} response
      let readyToListen = false; // Track when we're ready to listen for custom messages
...

ws.onopen = () => {
        console.log("SignalR WebSocket connection established");
        ws.send(handshakeData); // Step 1: Send handshake message

        ws.onmessage = (event) => {
          const rawMessage = event.data;
          const messages = rawMessage.split("\x1e").filter((m) => m);

          messages.forEach((message) => {
            try {
              const parsedMessage = JSON.parse(message);

              // Step 2: Check for initial empty response {}
              if (
                Object.keys(parsedMessage).length === 0 &&
                !receivedEmptyResponse
              ) {
                console.log("Received empty response {} from server.");
                receivedEmptyResponse = true;
                ws.send('{"type":6}\x1e'); // Step 3: Send type after  empty server response
              }
              // Step 4: Wait for server to respond with {"type":6}
              else if (
                parsedMessage.type === 6 &&
                receivedEmptyResponse &&
                !readyToListen
              ) {
                console.log(
                  "Received server confirmation type 6. Ready for further messages.",
                );
                readyToListen = true;
                resolve(); // Signal that we're ready for payment deposit request
              }
              // Only listen for custom messages 
              // ReceivePaymentStatusUpdate and ReceiveBalanceUpdate
              // after setup is complete
              if (
                readyToListen &&
                parsedMessage.type === 1 &&
                parsedMessage.target
              ) {
                if (
                  parsedMessage.target === "ReceivePaymentStatusUpdate" &&
                  onPaymentStatusUpdate
                ) {
                  onPaymentStatusUpdate(parsedMessage.arguments[0]);
                }
                if (
                  parsedMessage.target === "ReceiveBalanceUpdate" &&
                  onBalanceUpdate
                ) {
                  onBalanceUpdate(parsedMessage.arguments[0]);
                }
              }
            } catch (error) {
              console.error("Failed to parse SignalR message:", error);
            }
          });
        };
        ws.onerror = (error) => {
          console.log(WebSocket error: ${error.message});
          reject(error);
        };
        ws.onclose = () => {
          console.log("SignalR WebSocket connection closed");
        };
      };
    });
  },
);

connectWStoVerifyBalance() {
      // Construct your WebSocket SignalR URL
      // The URL is based on configuration for specific testing 
      // environment
      const urlWS = `${envConfig.webSocketAPI}${bearerToken}`;
      cy.connectWStoListen(urlWS, {
        onPaymentStatusUpdate: (paymentStatus) => {
          const parsedStatus = JSON.parse(paymentStatus);
          // Wait and retry if payment status is still 'pending'
          if (parsedStatus.status === "pending") {
            console.warn("Payment status is pending. Retrying...");
          }
          // Do an assertion that status is updated to Success
          expect(parsedStatus.status).to.equal("success");
          console.log("Payment status updated successfully:", parsedStatus);
        },
        onBalanceUpdate: (updatedBalance) => {
          // Do required assertions for a balance update
          // Save new balance value if it is necessary
          console.log("Balance updated successfully:", updatedBalance);
          // Close WebSocket connection
          const ws = Cypress.env("currentWebSocket");
          if (ws) ws.close();
        },
      });
    });
  }

describe("Deposit Feature - Real-Time WebSocket Validation", () => {

  it(`Verify that a user can deposit min amount and payment is successful`, () => {
    // Step 1: User Registration & Setup
    cy.registerNewUser();
    cy.confirmUserIsRegistered();

    // Step 2: Establish WebSocket Connection for Balance Monitoring
    // using our created method
    cy.connectWStoVerifyBalance();

    // Step 3: Navigate to payments and do required actions to
    // initiate a deposit transaction
    cy.navigateToPayments();
    cy.accessDepositTab();
    cy.verifyMinimumDepositAmount();
    cy.validatePendingPaymentStatus();

    // Step 4: Simulate payment process via API/webhook/UI
    cy.updateDepositStatusViaAPI();

    // Step 5: Verify successful payment update on UI
    cy.validateSuccessfulPaymentMessage();
  });
});