proton-c/bindings/ruby/spec/qpid/proton/messenger_spec.rb

#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements.  See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership.  The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not use this file except in compliance
# with the License.  You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

require "spec_helper"

module Qpid

  module Proton

    describe "A messenger" do

      before (:each) do
        @messenger = Qpid::Proton::Messenger::Messenger.new
      end

      after (:each) do
        begin
          @messenger.stop
        rescue ProtonError => error
          # ignore this error
        end
      end

      it "will generate a name if one is not provided" do
        expect(@messenger.name).to_not be_nil
      end

      it "will accept an assigned name" do
        name = random_string(16)
        msgr = Qpid::Proton::Messenger::Messenger.new(name)
        expect(msgr.name).to eq(name)
      end

      it "raises an error on a nil timeout" do
        expect {
          @messenger.timeout = nil
        }.to raise_error(TypeError)
      end

      it "can have a negative timeout" do
        timeout = (0 - rand(65535))
        @messenger.timeout = timeout
        expect(@messenger.timeout).to eq(timeout)
      end

      it "has a timeout" do
        timeout = rand(65535)
        @messenger.timeout = timeout
        expect(@messenger.timeout).to eq(timeout)
      end

      it "has an error number" do
        expect(@messenger.error?).to eq(false)
        expect(@messenger.errno).to eq(0)
        # force an error
        expect {
          @messenger.subscribe("amqp://~#{random_string}")
        }.to raise_error(ProtonError)
        expect(@messenger.error?).to eq(true)
        expect(@messenger.errno).to_not eq(0)
      end

      it "has an error message" do
        expect(@messenger.error?).to eq(false)
        expect(@messenger.error).to be_nil
        # force an error
        expect {
          @messenger.subscribe("amqp://~#{random_string}")
        }.to raise_error(ProtonError)
        expect(@messenger.error?).to eq(true)
        expect(@messenger.errno).to_not be_nil
      end

      it "can be started" do
        expect {
          @messenger.start
        }.to_not raise_error
      end

      it "can be stopped" do
        expect {
          @messenger.stop
        }.to_not raise_error
      end

      it "raises an error when subscribing to a nil address" do
        expect {
          @messenger.subscribe(nil)
        }.to raise_error(TypeError)
      end

      it "raises an error when subscribing to an invalid address" do
        expect {
          @messenger.subscribe("amqp://~#{random_string}")
        }.to raise_error(ProtonError)
        expect(@messenger.error?).to eq(true)
        expect(@messenger.errno).to_not eq(nil)
      end

      it "can have a nil certificate" do
        expect {
          @messenger.certificate = nil
          expect(@messenger.certificate).to be_nil
        }.to_not raise_error
      end

      it "can have a certificate" do
        cert = random_string(128)
        @messenger.certificate = cert
        expect(@messenger.certificate).to eq(cert)
      end

      it "can have a nil private key" do
        expect {
          @messenger.private_key = nil
          expect(@messenger.private_key).to be_nil
        }.to_not raise_error
      end

      it "can have a private key" do
        key = random_string(128)
        @messenger.private_key = key
        expect(@messenger.private_key).to eq(key)
      end

      it "can have a nil trusted certificates" do
        expect {
          @messenger.trusted_certificates = nil
          expect(@messenger.trusted_certificates).to be_nil
        }.to_not raise_error
      end

      it "has a list of trusted certificates" do
        certs = random_string(128)
        @messenger.trusted_certificates = certs
        expect(@messenger.trusted_certificates).to eq(certs)
      end

      it "raises an error on a nil outgoing window" do
        expect {
          @messenger.outgoing_window = nil
        }.to raise_error(TypeError)
      end

      it "raises an error on a non-numeric outgoing window" do
        expect {
          @messenger.outgoing_window = random_string(16)
        }.to raise_error(TypeError)
      end

      it "can have a negative outgoing window" do
        window = 0 - (rand(256) + 1)
        @messenger.outgoing_window = window
        expect(@messenger.outgoing_window).to eq(window)
      end

      it "can have a positive outgoing window" do
        window = (rand(256) + 1)
        @messenger.outgoing_window = window
        expect(@messenger.outgoing_window).to eq(window)
      end

      it "can have a zero outgoing window" do
        window = 0
        @messenger.outgoing_window = window
        expect(@messenger.outgoing_window).to eq(window)
      end

      it "raises an error on a nil incoming window" do
        expect {
          @messenger.incoming_window = nil
        }.to raise_error(TypeError)
      end

      it "raises an error on a non-numeric incoming window" do
        expect {
          @messenger.incoming_window = random_string(16)
        }.to raise_error(TypeError)
      end

      it "can have a negative incoming window" do
        window = 0 - (rand(256) + 1)
        @messenger.incoming_window = window
        expect(@messenger.incoming_window).to eq(window)
      end

      it "can have a positive incoming window" do
        window = (rand(256) + 1)
        @messenger.incoming_window = window
        expect(@messenger.incoming_window).to eq(window)
      end

      it "can have a zero incoming window" do
        window = 0
        @messenger.incoming_window = window
        expect(@messenger.incoming_window).to eq(window)
      end

      it "can be put into passive mode" do
        @messenger.passive = true
        expect(@messenger.passive?).to eq(true)
      end

      it "can be taken out of passive mode" do
        @messenger.passive = false
        expect(@messenger.passive?).to eq(false)
      end

      it "can clear non-existent errors with failing" do
        expect {
          @messenger.clear_error
        }.to_not raise_error
      end

      it "can clear errors" do
        begin
          @messenger.accept # should cause an error
        rescue; end

        expect(@messenger.error).to_not be_nil
        @messenger.clear_error
        expect(@messenger.error).to be_nil
      end

      describe "once started" do

        before (:each) do
          @messenger.start
        end

        after (:each) do
          begin
            @messenger.stop
          rescue ProtonError => error
            # ignore this error
          end
        end

        it "can subscribe to an address" do
          expect(@messenger.subscribe("amqp://~0.0.0.0:#{5700+rand(1024)}")).to_not be_nil
        end

        it "returns a tracker's status"

        describe "and subscribed to an address" do

          before (:each) do
            # create a receiver
            @port = 5700 + rand(1024)
            @receiver = Qpid::Proton::Messenger::Messenger.new("receiver")
            @receiver.subscribe("amqp://~0.0.0.0:#{@port}")
            @messenger.timeout = 0
            @receiver.timeout = 0
            @receiver.start

            Thread.new do
              @receiver.receive(10)
            end

            @msg = Qpid::Proton::Message.new
            @msg.address = "amqp://0.0.0.0:#{@port}"
            @msg.body = "Test sent #{Time.new}"
          end

          after (:each) do
            begin
              @messenger.stop
            rescue ProtonError => error
              # ignore this error
            end
            begin
              @receiver.stop
            rescue
            end
          end

          it "raises an error when queueing a nil message" do
            expect {
              @messenger.put(nil)
            }.to raise_error(TypeError)
          end

          it "raises an error when queueing an invalid object" do
            expect {
              @messenger.put("This is not a message")
            }.to raise_error(::ArgumentError)
          end

          it "can place a message in the outgoing queue" do
            expect {
              @messenger.put(@msg)
            }.to_not raise_error
          end

          it "can send with an empty queue"

          describe "with a an outgoing tracker" do

            before(:each) do
              @messenger.put(@msg)
              @tracker = @messenger.outgoing_tracker
            end

            it "has an outgoing tracker" do
              expect(@tracker).to_not be_nil
            end

            it "returns a tracker's status"

            it "raises an error when settling with a nil tracker" do
              expect {
                @messenger.settle(nil)
              }.to raise_error(TypeError)
            end

            it "can settle a tracker's status" do
              @messenger.settle(@tracker)
            end

            it "raises an error when checking status on a nil tracker" do
              expect {
                @messenger.status(nil)
              }.to raise_error(TypeError)
            end

            it "raises an error when checking status on an invalid tracker" do
              expect {
                @messenger.status(random_string(16))
              }.to raise_error(TypeError)
            end

            it "can check the status of a tracker" do
              expect(@messenger.status(@tracker)).to_not be_nil
            end

          end

          it "has an incoming tracker"
          it "can reject an incoming message"

          it "raises an error when accepting with an invalid tracker" do
            expect {
              @messenger.accept(random_string(16))
            }.to raise_error(TypeError)
          end

          it "can accept a message"

          it "raises an error when rejecting with an invalid tracker" do
            expect {
              @messenger.accept(random_string(16))
            }.to raise_error(TypeError)
          end

          describe "with messages sent" do

            before (:each) do
              @messenger.put(@msg)
            end

            it "can send messages"

            it "raises an error when receiving with a nil max" do
              expect {
                @messenger.receive(nil)
              }.to raise_error(TypeError)
            end

            it "raises an error when receiving with a non-numeric max" do
              expect {
                @messenger.receive("farkle")
              }.to raise_error(TypeError)
            end

            it "can receive messages"
            it "and create a new message when one wasn't provided"
            it "can get a message from the incoming queue"
            it "can tell how many outgoing messages are pending"
            it "can tell how many incoming messages are queued"

          end

        end

      end

    end

  end

end