rex/spec/server/message_parser_spec.rb

# require "eventmachine"
RSpec.describe Rex::Server::MessageParser do
  subject(:instance) { described_class.new }

  describe "#parse" do
    subject { instance.parse(message) }

    context "when message is not valid json" do
      let(:message) do
        "{{}}"
      end

      it { is_expected.to eq([false, [{error: :json_parse_error}]]) }
    end

    context "when message is not a valid message type" do
      let(:message) do
        {
          name: "unknown.request_type"
        }.to_json
      end

      it "returns an error" do
        expect(subject[0]).to be(false)
        expect(subject.dig(1, 0, :fragment)).to eq("#/name")
      end
    end

    context "when message does not match the schema" do
      let(:message) do
        {
          request_id: "-1",
          name: "order.create",
          type: "request",
          args: "test"
        }.to_json
      end

      it "returns an error" do
        expect(subject[0]).to be(false)
        expect(subject[1].length).to eq(2)
        expect(subject[1].map { _1[:fragment] }).to match_array(["#/request_id", "#/args"])
      end
    end

    context "when message is a order create request" do
      let(:message) do
        {
          request_id: 1,
          name: "order.create",
          type: "request",
          args: {
            quantity: 100,
            price: 10,
            side: :buy
          }
        }.to_json
      end

      it "returns a order create request" do
        expect(subject).to be_instance_of(Rex::Server::Messages::CreateOrderRequest)
        expect(subject.user_id).to eq(nil)
        expect(subject.side).to eq(:buy)
        expect(subject.price).to eq(10)
        expect(subject.quantity).to eq(100)
      end
    end

    context "when message is a order cancel request" do
      let(:message) do
        {
          request_id: 1,
          name: "order.cancel",
          type: "request",
          args: {
            id: 123
          }
        }.to_json
      end

      it "returns a order cancel request" do
        expect(subject).to be_instance_of(Rex::Server::Messages::CancelOrderRequest)
        expect(subject.user_id).to eq(nil)
        expect(subject.order_id).to eq(123)
      end
    end

    context "when message is a order book request" do
      let(:message) do
        {
          request_id: 1,
          name: "orderbook.fetch",
          type: "request",
          args: {}
        }.to_json
      end

      it "returns a fetch order book request" do
        expect(subject).to be_instance_of(Rex::Server::Messages::FetchOrderBookRequest)
        expect(subject.user_id).to eq(nil)
      end
    end

    context "when message is a fetch orders request" do
      let(:message) do
        {
          request_id: 1,
          name: "orders.fetch",
          type: "request",
          args: {}
        }.to_json
      end

      it "returns a fetch orders request" do
        expect(subject).to be_instance_of(Rex::Server::Messages::FetchOrdersRequest)
        expect(subject.user_id).to eq(nil)
      end
    end

    context "when message is a fetch trades request" do
      let(:message) do
        {
          request_id: 1,
          name: "trades.fetch",
          type: "request",
          args: {}
        }.to_json
      end

      it "returns a fetch trades request" do
        expect(subject).to be_instance_of(Rex::Server::Messages::FetchTradesRequest)
        expect(subject.user_id).to eq(nil)
      end
    end

    context "when message is an authenticate request" do
      let(:message) do
        {
          request_id: 1,
          name: "authenticate",
          type: "request",
          args: {
            user_id: "1"
          }
        }.to_json
      end

      it "returns a authenticate request" do
        expect(subject).to be_instance_of(Rex::Server::Messages::AuthenticateRequest)
        expect(subject.user_id).to eq("1")
      end
    end
  end
end