rabbitmq-definition 0.1.0

data/spec/fixtures/create.json

@@ -0,0 +1,18 @@
+{
+  "rabbit_version": "3.5.0",
+  "version": "20091026044709",
+  "vhosts": [
+    {
+      "name": "/test"
+    }
+  ],
+  "queues": [
+
+  ],
+  "bindings": [
+
+  ],
+  "exchanges": [
+
+  ]
+}

data/spec/fixtures/example1.json

@@ -0,0 +1,41 @@
+{
+  "rabbit_version": "3.5.0",
+  "version": "20091026044709",
+  "vhosts": [
+    { "name": "/test" }
+  ],
+  "queues": [
+    {
+      "name": "my-queue",
+      "vhost": "/test",
+      "durable": true,
+      "auto_delete": false,
+      "arguments": {
+        "x-dead-letter-exchange": "dead"
+      }
+    }
+  ],
+  "exchanges": [
+    {
+      "name": "my-exchange",
+      "vhost": "/test",
+      "type": "topic",
+      "durable": true,
+      "auto_delete": false,
+      "internal": false,
+      "arguments": {
+      }
+    }
+   ],
+  "bindings": [
+    {
+      "source": "my-exchange",
+      "vhost": "/test",
+      "destination": "my-queue",
+      "destination_type": "queue",
+      "routing_key": "my-routing-key.#",
+      "arguments": {
+      }
+    }
+  ]
+}

data/spec/helpers/listing_helper.rb

@@ -0,0 +1,23 @@
+module ListingHelper
+	def select_queues(client, vhost)
+		client.list_queues(vhost).select do |queue|
+			!is_default_entity?(queue.name)
+		end
+	end
+
+	def select_exchanges(client, vhost)
+		client.list_exchanges(vhost).select do |exchange|
+			!is_default_entity?(exchange.name)
+		end
+	end
+
+	def select_bindings(client, vhost)
+		client.list_bindings(vhost).select do |binding|
+			!is_default_entity?(binding.source)
+		end
+	end
+
+	def is_default_entity?(name)
+		name.empty? || name.start_with?("amq.")
+	end
+end

data/spec/helpers/matchers.rb

@@ -0,0 +1,29 @@
+RSpec::Matchers.define :match_definition do |expected_example|
+  def extract_definition_comparable_json(path)
+    if File.exist?(path)
+      content = File.read(path) 
+      json = JSON.parse(content)
+      json.except('rabbit_version')
+    else
+      nil
+    end
+  end
+
+  match do |actual_path|
+    @actual_json = extract_definition_comparable_json(actual)
+    expected_path = File.expand_path("../../fixtures/" + expected_example, __FILE__)
+    @expected_json = extract_definition_comparable_json(expected_path)
+  end
+
+  failure_message do |actual_path|
+    if @actual_json.nil?
+      "'#{actual_path}' file does NOT exist"
+    else
+      "expected: \n#{@actual_json.pretty_inspect}\n\n to match definition: \n#{@expected_json.pretty_inspect}\n\n"
+    end
+  end
+
+  description do
+    "matches definition in '#{expected_example}'"
+  end
+end

data/spec/integration/rabbitmq_definition_spec.rb

@@ -0,0 +1,101 @@
+describe "RabbitMQ::Definition" do
+  include ListingHelper
+  let(:client) { RabbitMQ::Definition.client }
+  let(:vhost) { "/test" }
+  let(:file_path) { RabbitMQ::Definition::FileDefinition.file_path }
+
+  before do
+    WebMock.disable_net_connect!(:allow_localhost => true)
+    allow(RabbitMQ::Definition::FileDefinition).to receive(:file_path).and_call_original
+    client.delete_vhost('/test') rescue nil
+    client.create_vhost('/other-test-vhost') # existing unrelated vhost
+    File.delete(file_path) if File.exist?(file_path)
+    time = Time.iso8601("2009-10-26T04:47:09Z")
+    Timecop.freeze(time)
+  end
+
+  after do
+    client.delete_vhost('/other-test-vhost')
+    WebMock.disable_net_connect!(:allow => "codeclimate.com")
+    Timecop.return
+  end
+
+  def read_fixture(path)
+    path = File.join(File.dirname(__FILE__), '../fixtures/', path)
+    File.read(path)
+  end
+
+  describe ".create" do
+    it "creates a vhost" do
+      initial_count = client.list_vhosts.count
+      RabbitMQ::Definition.create([vhost])
+      expect(client.list_vhosts.count).to eq(initial_count + 1)
+    end
+
+    it "stores the rabbitmq_definition.json file" do
+      RabbitMQ::Definition.create([vhost])
+      expect(file_path).to match_definition('create.json')
+    end
+  end
+
+  describe ".drop" do
+    before do
+      fixture = read_fixture('example1.json')
+      File.write(file_path, fixture)
+      expect_any_instance_of(RabbitMQ::Definition::Drop).to receive(:agree).and_return(true)
+      client.upload_definitions(fixture)
+      client.update_permissions_of(vhost, 'guest', {
+        :configure => ".*",
+        :write     => ".*",
+        :read       => ".*"
+      })
+    end
+
+    it "removes virtual host" do
+      RabbitMQ::Definition.drop
+      vhost_names = client.list_vhosts.map{|v| v[:name]}
+      expect(vhost_names).not_to include('/test')
+    end
+
+    it "does NOT remove other virtual hosts" do
+      RabbitMQ::Definition.drop
+      vhost_names = client.list_vhosts.map{|v| v[:name]}
+      expect(vhost_names).to include('/other-test-vhost')
+    end
+  end
+
+  describe ".dump" do
+    before do
+      File.write(file_path, read_fixture('create.json'))
+      client.upload_definitions(read_fixture('example1.json'))
+      client.update_permissions_of(vhost, 'guest', {
+        :configure => ".*",
+        :write     => ".*",
+        :read       => ".*"
+      })
+    end
+
+    it "saves the definition" do
+      RabbitMQ::Definition.dump
+      expect(file_path).to match_definition('example1.json')
+    end
+  end
+
+  describe ".load" do
+    before do
+      File.write(file_path, read_fixture('example1.json'))
+      client.upload_definitions(read_fixture('create.json'))
+      client.update_permissions_of(vhost, 'guest', {
+        :configure => ".*",
+        :write     => ".*",
+        :read       => ".*"
+      })
+    end
+
+    it "loads the definition" do
+      RabbitMQ::Definition.load
+      RabbitMQ::Definition.dump
+      expect(file_path).to match_definition('example1.json')
+    end
+  end
+end

data/spec/rabbitmq_definition/command_spec.rb

@@ -0,0 +1,23 @@
+describe RabbitMQ::Definition::Command do
+
+  describe "#initialize" do
+    it "sets the client" do
+      client = double("client")
+      command = RabbitMQ::Definition::Command.new(client, false)
+      expect(command.client).to eq(client)
+    end
+
+    it "sets the verbosity" do
+      command = RabbitMQ::Definition::Command.new(nil, true)
+      expect(command.verbose).to eq(true)
+    end
+  end
+
+  describe "#execute" do
+    it "raises NotImplementedError" do
+      expect{
+        RabbitMQ::Definition::Command.new(nil, nil).execute
+      }.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/rabbitmq_definition/create_spec.rb

@@ -0,0 +1,60 @@
+describe RabbitMQ::Definition::Create do
+  let(:client) do
+    double("client",
+      :create_vhost => true,
+      :update_permissions_of => true,
+      :endpoint => ENV['RABBITMQ_MANAGEMENT_URL']
+    )
+  end
+  before { allow(RabbitMQ::Definition::Dump).to receive(:run).and_return(true) }
+
+  context "when a definition file does already exist" do
+    before { allow(RabbitMQ::Definition::FileDefinition).to receive(:exists?).and_return(true) }
+
+    it "notifies about error when a definition file already exists" do
+      expect(RabbitMQ::Definition::Logger).to receive(:error).with("Definition file already exists in ./db/rabbitmq_definition.json").once
+      described_class.run(client, false, ["/"])
+    end
+
+    it "does NOT save the schema" do
+      expect_any_instance_of(RabbitMQ::Definition::FileDefinition).not_to receive(:save)
+      described_class.run(client, false, ["/"])
+    end
+  end
+
+  context "when a definition file does NOT exist" do
+    before { allow(RabbitMQ::Definition::FileDefinition).to receive(:exists?).and_return(false) }
+
+    it "notifies progress on each vhost when verobse" do
+      expect(RabbitMQ::Definition::Logger).to receive(:progress).with("Creating vhost '/'").once
+      described_class.run(client, true, ["/"])
+    end
+
+    it "creates each vhost" do
+      expect(client).to receive(:create_vhost).with('/').once
+      described_class.run(client, false, ["/"])
+    end
+
+    it "adds permission for the current user to each vhost" do
+      expect(client).to receive(:update_permissions_of)
+        .with(
+          '/',
+          'guest',
+          {
+            :configure => ".*",
+            :write     => ".*",
+            :read       => ".*"
+          }
+        ).once
+      described_class.run(client, false, ["/"])
+    end
+
+    it "dumps the created hosts definitions" do
+      expect(RabbitMQ::Definition::Dump).to receive(:run)
+        .with(client, false, ["/"])
+      described_class.run(client, false, ["/"])
+    end
+
+  end
+
+end

data/spec/rabbitmq_definition/drop_spec.rb

@@ -0,0 +1,74 @@
+describe RabbitMQ::Definition::Drop do
+  let(:client) { double("client", :delete_vhost => nil) }
+  let(:vhost) { '/' }
+  let(:definition) do
+    RabbitMQ::Definition::FileDefinition.new(
+      :vhosts => [{'name' => '/'}]
+    )
+  end
+  before do
+    allow(RabbitMQ::Definition::FileDefinition).to receive(:exists?).and_return(true)
+    allow(RabbitMQ::Definition::FileDefinition).to receive(:read).and_return(definition)
+    allow_any_instance_of(RabbitMQ::Definition::FileDefinition).to receive(:destroy).and_return(true)
+  end
+
+  context "when file definition does NOT exist" do
+    before { expect(RabbitMQ::Definition::FileDefinition).to receive(:exists?).and_return(false) }
+
+    it "notitifies the error" do
+      expect(RabbitMQ::Definition::Logger).to receive(:error).with("No definition with vhosts exists")
+      described_class.run(client, false)
+    end
+
+    it "does not delete any hosts" do
+      expect(client).not_to receive(:delete_host)
+      described_class.run(client, false)
+    end
+  end
+
+  context "when user does NOT want to proceed" do
+
+    before { expect_any_instance_of(described_class).to receive(:agree).and_return(false) }
+
+    it "notitifies the error" do
+      expect(RabbitMQ::Definition::Logger).to receive(:error).with("Aborted by user")
+      described_class.run(client, false)
+    end
+
+    it "does not delete any hosts" do
+      expect(client).not_to receive(:delete_host)
+      described_class.run(client, false)
+    end
+  end
+
+  context "when the user proceeds" do
+
+    before { expect_any_instance_of(described_class).to receive(:agree).and_return(true) }
+
+    it "notifies about progress" do
+      expect(RabbitMQ::Definition::Logger).to receive(:progress).with("Removing definition...").once
+      described_class.run(client, false)
+    end
+
+    it "notifies about progress deleting each host when verbose" do
+      expect(RabbitMQ::Definition::Logger).to receive(:progress).with("Deleting vhost '/'...").once
+      described_class.run(client, true)
+    end
+
+    it "deletes the vhosts" do
+      expect(client).to receive(:delete_vhost).with("/").once
+      described_class.run(client, false)
+    end
+
+    it "notifies about success" do
+      expect(RabbitMQ::Definition::Logger).to receive(:success).with("Done").once
+      described_class.run(client, false)
+    end
+
+    it "deletes the definition file" do
+      expect_any_instance_of(RabbitMQ::Definition::FileDefinition).to receive(:destroy).once
+      described_class.run(client, false)
+    end
+  end
+
+end

data/spec/rabbitmq_definition/dump_spec.rb

@@ -0,0 +1,147 @@
+describe RabbitMQ::Definition::Dump do
+  let(:list_definitions) do
+    {
+      'rabbit_version' => "3.5.0",
+      'vhosts' => [{'name' => '/'}, 'name' => '/other-vhost'],
+      'queues' => [
+        {
+          "name" => "my-queue",
+          "vhost" => "/",
+          "durable" => true,
+          "auto_delete" => false,
+          "arguments" => {
+            "x-dead-letter-exchange" => "dead"
+          }
+        },
+        {
+          "name" => "other-vhost-queue",
+          "vhost" => "/other-vhost"
+        }
+      ],
+      'exchanges' => [
+        {
+          "name" => "my-exchange",
+          "vhost" => "/",
+          "type" => "topic",
+          "durable" => true,
+          "auto_delete" => false,
+          "internal" => false,
+          "arguments" => {
+          }
+        },
+        {
+          "name" => "other-vhost-exchange",
+          "vhost" => "/other-vhost",
+          "type" => "topic",
+          "durable" => true,
+          "auto_delete" => false,
+          "internal" => false,
+          "arguments" => {
+          }
+        }
+      ],
+      'bindings' => [
+        {
+          "source" => "my-exchange",
+          "vhost" => "/",
+          "destination" => "my-queue",
+          "destination_type" => "queue",
+          "routing_key" => "my-routing-key.#",
+          "arguments" => {
+          }
+        },
+        {
+          "source" => "other-vhost-exchange",
+          "vhost" => "/other-vhost",
+          "destination" => "other-vhost-queue",
+          "destination_type" => "queue",
+          "routing_key" => "other-routing-key.#",
+          "arguments" => {
+          }
+        }
+      ]
+    }
+  end
+  let(:filtered_definition_hash) do
+    {
+      'rabbit_version' => "3.5.0",
+      'vhosts' => [
+        { 'name' => "/" }
+      ],
+      'queues' => [
+        {
+          "name" => "my-queue",
+          "vhost" => "/",
+          "durable" => true,
+          "auto_delete" => false,
+          "arguments" => {
+            "x-dead-letter-exchange" => "dead"
+          }
+        }
+      ],
+      'exchanges' => [
+        {
+          "name" => "my-exchange",
+          "vhost" => "/",
+          "type" => "topic",
+          "durable" => true,
+          "auto_delete" => false,
+          "internal" => false,
+          "arguments" => {
+          }
+        }
+      ],
+      'bindings' => [
+        {
+          "source" => "my-exchange",
+          "vhost" => "/",
+          "destination" => "my-queue",
+          "destination_type" => "queue",
+          "routing_key" => "my-routing-key.#",
+          "arguments" => {
+          }
+        }
+      ]
+    }
+  end
+  let(:client) do
+    double(
+      "client",
+      :list_definitions => list_definitions
+    )
+  end
+  before { allow_any_instance_of(RabbitMQ::Definition::FileDefinition).to receive(:save).and_return(true) }
+
+  it "notifies about progress" do
+    expect(RabbitMQ::Definition::Logger).to receive(:progress).with("Saving definition...").once
+    described_class.run(client, false, [])
+  end
+
+  it "notifies about definition payload when verbose" do
+    json = double("json")
+    allow_any_instance_of(RabbitMQ::Definition::FileDefinition).to receive(:to_json).and_return(json)
+    expect(RabbitMQ::Definition::Logger).to receive(:info).with(json).once
+    described_class.run(client, true, ['/'])
+  end
+
+  it "notifies success" do
+    expect(RabbitMQ::Definition::Logger).to receive(:success).with("Done").once
+    described_class.run(client, false, [])
+  end
+
+  it "generates the file definition with the filtered list definitions" do
+    definition = double("Definition")
+    expect(RabbitMQ::Definition::FileDefinition).to receive(:new).with(filtered_definition_hash).and_return(definition)
+    expect(definition).to receive(:save).once
+    described_class.run(client, false, ['/'])
+  end
+
+  it "generates the file definition with the filtered list definitions taking vhosts from files" do
+    original_definition = double(:vhosts => [{'name' => '/'}])
+    expect(RabbitMQ::Definition::FileDefinition).to receive(:read).and_return(original_definition)
+    definition = double("Definition")
+    expect(RabbitMQ::Definition::FileDefinition).to receive(:new).with(filtered_definition_hash).and_return(definition)
+    expect(definition).to receive(:save).once
+    described_class.run(client, false)
+  end
+end