require 'spec_helper'

module MessageDriver::Message
  describe Base do
    describe "#initialize" do
      let(:body) { "The message body" }
      let(:headers) { { foo: :bar, bar: :baz} }
      let(:properties) { {persistent: true, client_ack: true} }
      let(:ctx) { double("adapter_context") }

      context "sets the body, header and properites on initialization" do
        subject { described_class.new(ctx, body, headers, properties) }

        its(:ctx) { should be(ctx) }
        its(:body) { should eq(body) }
        its(:headers) { should eq(headers) }
        its(:properties) { should eq(properties) }
      end
    end

    let(:logger) { MessageDriver.logger }
    let(:ctx) { double("adapter_context") }
    let(:options) { double("options") }
    subject(:message) { described_class.new(ctx, "body", {}, {}) }

    describe "#ack" do
      before do
        allow(ctx).to receive(:ack_message)
      end
      context "when the adapter supports client acks" do
        before do
          allow(ctx).to receive(:supports_client_acks?) { true }
        end
        it "calls #ack_message with the message" do
          subject.ack
          expect(ctx).to have_received(:ack_message).with(subject, {})
        end
        it "passes the supplied options to ack_message" do
          subject.ack(options)
          expect(ctx).to have_received(:ack_message).with(subject, options)
        end
      end
      context "when the adapter doesn't support client acks" do
        before do
          allow(ctx).to receive(:supports_client_acks?) { false }
        end
        it "doesn't call #ack_message" do
          subject.ack
          expect(ctx).not_to have_received(:ack_message)
        end
        it "logs a warning" do
          allow(logger).to receive(:debug)
          subject.ack
          expect(logger).to have_received(:debug).with("this adapter does not support client acks")
        end
      end
    end

    describe "#nack" do
      before do
        allow(ctx).to receive(:nack_message)
      end
      context "when the adapter supports client nacks" do
        before do
          allow(ctx).to receive(:supports_client_acks?) { true }
        end
        it "calls #nack_message with the message" do
          subject.nack
          expect(ctx).to have_received(:nack_message).with(subject, {})
        end
        it "passes the supplied options to nack_message" do
          subject.nack(options)
          expect(ctx).to have_received(:nack_message).with(subject, options)
        end
      end
      context "when the adapter doesn't support client nacks" do
        before do
          allow(ctx).to receive(:supports_client_acks?) { false }
        end
        it "doesn't call #nack_message" do
          subject.nack
          expect(ctx).not_to have_received(:nack_message)
        end
        it "logs a warning" do
          allow(logger).to receive(:debug)
          subject.nack
          expect(logger).to have_received(:debug).with("this adapter does not support client acks")
        end
      end
    end
  end
end