pantry 0.0.0 → 0.1.0

data/test/unit/communication/send_socket_test.rb

@@ -0,0 +1,19 @@
+require 'unit/test_helper'
+
+describe Pantry::Communication::SendSocket do
+
+  before do
+    Celluloid.boot
+  end
+
+  let(:security) { Pantry::Communication::Security.new_client }
+
+  it "opens a ZMQ DealerSocket, bound to host / port" do
+    Celluloid::ZMQ::DealerSocket.any_instance.expects(:linger=).with(0)
+    Celluloid::ZMQ::DealerSocket.any_instance.expects(:connect).with("tcp://host:1234")
+
+    socket = Pantry::Communication::SendSocket.new("host", 1234, security)
+    socket.open
+  end
+
+end

data/test/unit/communication/serialize_message_test.rb

@@ -0,0 +1,128 @@
+require 'unit/test_helper'
+
+describe Pantry::Communication::SerializeMessage do
+
+  describe ".to_zeromq" do
+
+    let(:pantry_message) do
+      message = Pantry::Message.new
+      message.to = "to"
+      message.from = "from"
+      message
+    end
+
+    it "builds a list of message parts containing to, metadata, and body" do
+      pantry_message << "Test Body"
+
+      zmq_message = Pantry::Communication::SerializeMessage.to_zeromq(pantry_message)
+
+      assert_equal 3, zmq_message.length
+      assert_equal "to", zmq_message[0]
+      assert_equal "Test Body", zmq_message[2]
+    end
+
+    it "ensures `to` is always a string" do
+      pantry_message.to = nil
+      zmq_message = Pantry::Communication::SerializeMessage.to_zeromq(pantry_message)
+
+      assert_equal "", zmq_message[0]
+    end
+
+    it "serializes the metadata as JSON" do
+      zmq_message = Pantry::Communication::SerializeMessage.to_zeromq(pantry_message)
+
+      metadata = JSON.parse(zmq_message[1])
+
+      assert_equal "to", metadata["to"]
+      assert_equal "from", metadata["from"]
+    end
+
+    it "ensures all parts of the body are strings" do
+      pantry_message << 1
+      pantry_message << 2
+
+      zmq_message = Pantry::Communication::SerializeMessage.to_zeromq(pantry_message)
+
+      assert_equal "1", zmq_message[2]
+      assert_equal "2", zmq_message[3]
+    end
+
+    it "turns nil entries into strings" do
+      pantry_message << nil
+      pantry_message << "this"
+
+      zmq_message = Pantry::Communication::SerializeMessage.to_zeromq(pantry_message)
+
+      assert_equal "", zmq_message[2]
+      assert_equal "this", zmq_message[3]
+    end
+
+    it "converts hashes in the body to JSON" do
+      pantry_message << {:key => "value"}
+
+      zmq_message = Pantry::Communication::SerializeMessage.to_zeromq(pantry_message)
+
+      body = JSON.parse(zmq_message[2][1..-1])
+      assert_equal "value", body["key"]
+    end
+
+    it "converts arrays in the body to JSON" do
+      pantry_message << ["some", "values", 1, 2, true]
+
+      zmq_message = Pantry::Communication::SerializeMessage.to_zeromq(pantry_message)
+
+      body = JSON.parse(zmq_message[2][1..-1])
+      assert_equal ["some", "values", 1, 2, true], body
+    end
+
+  end
+
+  describe ".from_zeromq" do
+
+    let(:is_json) { Pantry::Communication::SerializeMessage::IS_JSON }
+
+    it "takes an array and builds a Message from the parts" do
+      parts = [ "source", {}.to_json, "body1" ]
+
+      message = Pantry::Communication::SerializeMessage.from_zeromq(parts)
+
+      assert_equal "source", message.to
+      assert_equal ["body1"], message.body
+    end
+
+    it "parses out JSON into a Hash" do
+      parts = [ "source", {:type => "command"}.to_json, "body1" ]
+
+      message = Pantry::Communication::SerializeMessage.from_zeromq(parts)
+
+      assert_equal "command", message.type
+    end
+
+    it "handles JSON based body entries" do
+      parts = [ "source", {}.to_json, is_json + {:key => "value"}.to_json ]
+
+      message = Pantry::Communication::SerializeMessage.from_zeromq(parts)
+
+      assert_equal "value", message.body[0][:key]
+    end
+
+    it "handles Array based body entries" do
+      parts = [ "source", {}.to_json, is_json + [1, 2, 3, "go"].to_json ]
+
+      message = Pantry::Communication::SerializeMessage.from_zeromq(parts)
+
+      assert_equal [1, 2, 3, "go"], message.body[0]
+    end
+
+    it "returns raw parts if they don't parse as JSON" do
+      parts = [ "source", {}.to_json, "{ blah blah thing", "[notreallyanarray" ]
+
+      message = Pantry::Communication::SerializeMessage.from_zeromq(parts)
+
+      assert_equal "{ blah blah thing", message.body[0]
+      assert_equal "[notreallyanarray", message.body[1]
+    end
+
+  end
+
+end

data/test/unit/communication/server_test.rb

@@ -0,0 +1,106 @@
+require 'unit/test_helper'
+
+describe Pantry::Communication::Server do
+
+  before do
+    Pantry::Communication::PublishSocket.any_instance.stubs(:open)
+
+    Pantry::Communication::ReceiveSocket.any_instance.stubs(:add_listener)
+    Pantry::Communication::ReceiveSocket.any_instance.stubs(:open)
+
+    Pantry::Communication::FileService.any_instance.stubs(:start_server)
+  end
+
+  it "opens a publish socket for communication" do
+    Pantry::Communication::PublishSocket.any_instance.expects(:open)
+
+    server = Pantry::Communication::Server.new(nil)
+    server.run
+  end
+
+  it "opens a receive socket for communication" do
+    server = Pantry::Communication::Server.new(nil)
+
+    Pantry::Communication::ReceiveSocket.any_instance.expects(:add_listener).with(server)
+    Pantry::Communication::ReceiveSocket.any_instance.expects(:open)
+
+    server.run
+  end
+
+  it "starts up a local file service" do
+    server = Pantry::Communication::Server.new(nil)
+
+    Pantry::Communication::FileService.any_instance.expects(:start_server)
+
+    server.run
+  end
+
+  describe "#publish_message" do
+    let(:listener) { Pantry::Server.new }
+    let(:msg) { Pantry::Message.new }
+    let(:server)  { Pantry::Communication::Server.new(listener) }
+
+    before do
+      server.run
+    end
+
+    it "uses the publish socket to send messages to clients" do
+      Pantry::Communication::PublishSocket.any_instance.expects(:send_message).with(msg)
+
+      server.publish_message(msg)
+    end
+
+    it "sets the from of the message to the sender" do
+      Pantry::Communication::PublishSocket.any_instance.expects(:send_message).with do |message|
+        listener.identity == message.from
+      end
+
+      server.publish_message(msg)
+    end
+  end
+
+  describe "Message forwarding" do
+    let(:listener) { Pantry::Server.new }
+    let(:msg) {
+      m = Pantry::Message.new
+      m.from = "client427"
+      m
+    }
+    let(:server)  { Pantry::Communication::Server.new(listener) }
+
+    before do
+      server.run
+    end
+
+    it "publishes the message to connected clients untouched" do
+      msg.to = "pantry"
+
+      Pantry::Communication::PublishSocket.any_instance.expects(:send_message).with(msg)
+      server.forward_message(msg)
+
+      assert msg.forwarded?, "Message should have been marked as forwarded"
+    end
+
+    it "forwards off responses to forwarded messages" do
+      msg.to = "client500"
+      msg.forwarded!
+
+      Pantry::Communication::PublishSocket.any_instance.expects(:send_message).with(msg)
+      server.handle_message(msg)
+    end
+  end
+
+  it "sends a message to a single client via identity, returning a future" do
+    server = Pantry::Communication::Server.new(nil)
+    server.run
+
+    message = Pantry::Message.new("message")
+    Pantry::Communication::PublishSocket.any_instance.expects(:send_message).with(message)
+
+    future = server.send_request(message)
+
+    assert_not_nil future
+    assert_not future.ready?
+  end
+
+end

data/test/unit/communication/subscribe_socket_test.rb

@@ -0,0 +1,46 @@
+require 'unit/test_helper'
+
+describe Pantry::Communication::SubscribeSocket do
+
+  before do
+    Celluloid.init
+
+    Celluloid::ZMQ::SubSocket.any_instance.stubs(:linger=)
+    Celluloid::ZMQ::SubSocket.any_instance.stubs(:connect)
+    Celluloid::ZMQ::SubSocket.any_instance.stubs(:subscribe)
+  end
+
+  let(:security) { Pantry::Communication::Security.new_client }
+
+  it "binds and subscribes to the given host and port" do
+    Celluloid::ZMQ::SubSocket.any_instance.expects(:linger=).with(0)
+    Celluloid::ZMQ::SubSocket.any_instance.expects(:connect).with("tcp://host:1235")
+    Celluloid::ZMQ::SubSocket.any_instance.expects(:subscribe).with("")
+
+    socket = Pantry::Communication::SubscribeSocket.new("host", 1235, security)
+    socket.open
+  end
+
+  describe "subscription filtering" do
+    it "subscribes to the stream according to filter options given" do
+      socket = Pantry::Communication::SubscribeSocket.new("host", 1235, security)
+      socket.filter_on(Pantry::Communication::ClientFilter.new(application: "pantry"))
+
+      Celluloid::ZMQ::SubSocket.any_instance.expects(:subscribe).with("pantry")
+
+      socket.open
+    end
+
+    it "subscribes to multiple streams to support nested scoping" do
+      socket = Pantry::Communication::SubscribeSocket.new("host", 1235, security)
+      socket.filter_on(Pantry::Communication::ClientFilter.new(
+        application: "pantry", environment: "test"))
+
+      Celluloid::ZMQ::SubSocket.any_instance.expects(:subscribe).with("pantry")
+      Celluloid::ZMQ::SubSocket.any_instance.expects(:subscribe).with("pantry.test")
+
+      socket.open
+    end
+  end
+
+end

data/test/unit/communication/wait_list_test.rb

@@ -0,0 +1,60 @@
+require 'unit/test_helper'
+
+describe Pantry::Communication::WaitList do
+
+  before do
+    Celluloid.init
+
+    @wait_list = Pantry::Communication::WaitList.new
+    @message = Pantry::Message.new("do_something")
+
+    @future = @wait_list.wait_for(@message)
+  end
+
+  it "creates and returns a future waiting for a response for the given identity and message" do
+    assert !@future.ready?, "Future should not have been ready with information"
+  end
+
+  it "knows if the given message matches a waiting future" do
+    assert @wait_list.waiting_for?(@message), "Wait List should be waiting for this message"
+  end
+
+  it "fulfills the waiting future if a message is received matching the waiting future" do
+    @message.from = "identity"
+    @message        << "The new body"
+    @wait_list.received(@message)
+
+    assert @future.ready?, "Future has not yet received information"
+    assert_equal ["The new body"], @future.value.body
+
+    assert_false @wait_list.waiting_for?(@message), "Future was not removed from the wait list"
+  end
+
+  it "allows multiple entries for a given identity and message type" do
+    wait_list = Pantry::Communication::WaitList.new
+
+    m1 = Pantry::Message.new("do_something")
+    m1.from = "client"
+
+    m2 = Pantry::Message.new("do_something")
+    m2.from = "client"
+
+    m3 = Pantry::Message.new("do_something")
+    m3.from = "client"
+
+    future1 = wait_list.wait_for(m1)
+    future2 = wait_list.wait_for(m2)
+    future3 = wait_list.wait_for(m3)
+
+    assert wait_list.waiting_for?(m1)
+
+    wait_list.received(m1)
+    wait_list.received(m2)
+    wait_list.received(m3)
+
+    assert future1.ready?, "First future was not ready"
+    assert future2.ready?, "Second future was not ready"
+    assert future3.ready?, "Third future was not ready"
+  end
+
+end

data/test/unit/communication/writing_socket_test.rb

@@ -0,0 +1,46 @@
+require 'unit/test_helper'
+
+describe Pantry::Communication::WritingSocket do
+
+  class TestWriter < Pantry::Communication::WritingSocket
+    attr_accessor :socket_impl
+
+    def build_socket
+      @socket_impl
+    end
+
+    def open_socket(socket)
+    end
+  end
+
+  let(:security) { Pantry::Communication::Security.new_client }
+
+  it "serializes a message and sends it down the pipe" do
+    zmq_socket = Class.new do
+      attr_accessor :written, :linger
+
+      def set(*options)
+      end
+
+      def write(message_body)
+        @written = message_body
+      end
+    end.new
+
+    writer = TestWriter.new("host", 1234, security)
+    writer.socket_impl = zmq_socket
+    writer.open
+
+    message = Pantry::Message.new("message_type")
+    message.to = "stream"
+    message << "message_body_1"
+    message << "message_body_2"
+
+    writer.send_message(message)
+
+    assert_equal(
+      ["stream", message.metadata.to_json, "message_body_1", "message_body_2"],
+      zmq_socket.written
+    )
+  end
+end

data/test/unit/config_test.rb

@@ -0,0 +1,150 @@
+require 'unit/test_helper'
+
+describe Pantry::Config do
+
+  let(:pantry_config) { Pantry::Config.new }
+
+  it "ensures only one Config object exists via Pantry.config" do
+    config = Pantry.config
+    assert_same config, Pantry.config
+  end
+
+  describe "Global Configs" do
+    it "has an entry for logging destination" do
+      pantry_config.log_to = "stdout"
+      assert_equal "stdout", pantry_config.log_to
+    end
+
+    it "has an entry for the log level" do
+      assert_equal "info", pantry_config.log_level
+
+      pantry_config.log_level = "warn"
+      assert_equal "warn", pantry_config.log_level
+    end
+
+    it "has an entry for the syslog program name" do
+      assert_equal "pantry", pantry_config.syslog_program_name
+
+      pantry_config.syslog_program_name = "client"
+      assert_equal "client", pantry_config.syslog_program_name
+    end
+
+    it "has an entry for the data dir" do
+      pantry_config.root_dir = "dir"
+      assert_equal "dir", pantry_config.root_dir
+    end
+
+    it "can load values from a given YAML file" do
+      config_file = fixture_path("config.yml")
+      pantry_config.load_file(config_file)
+
+      assert_equal "/var/log/pantry.log", pantry_config.log_to
+      assert_equal "warn", pantry_config.log_level
+      assert_equal "testing", pantry_config.syslog_program_name
+      assert_equal "/tmp/data", pantry_config.root_dir
+    end
+
+    it "does not set values to nil if not in the config" do
+      config_file = fixture_path("empty.yml")
+      pantry_config.load_file(config_file)
+
+      assert_equal "info", pantry_config.log_level
+      assert_equal "pantry", pantry_config.syslog_program_name
+    end
+  end
+
+  describe "Communication Configuration" do
+    it "has an entry for the server host name" do
+      pantry_config.server_host = "127.0.0.1"
+      assert_equal "127.0.0.1", pantry_config.server_host
+    end
+
+    it "has an entry for the pub / sub port" do
+      pantry_config.pub_sub_port = 100
+      assert_equal 100, pantry_config.pub_sub_port
+    end
+
+    it "has an entry for the client-info receive port" do
+      pantry_config.receive_port = 7788
+      assert_equal 7788, pantry_config.receive_port
+    end
+
+    it "has an entry for the file service port" do
+      pantry_config.file_service_port = 1122
+      assert_equal 1122, pantry_config.file_service_port
+    end
+
+    it "has an entry for the security strategy in use" do
+      pantry_config.security = "curve"
+      assert_equal "curve", pantry_config.security
+    end
+
+    it "can load values from a given YAML file" do
+      config_file = fixture_path("config.yml")
+      pantry_config.load_file(config_file)
+
+      assert_equal "10.0.0.1", pantry_config.server_host
+      assert_equal 12345, pantry_config.pub_sub_port
+      assert_equal 54321, pantry_config.receive_port
+      assert_equal 35412, pantry_config.file_service_port
+      assert_equal "curve", pantry_config.security
+    end
+
+    it "does not set values to nil if not in the config" do
+      config_file = fixture_path("empty.yml")
+      pantry_config.load_file(config_file)
+
+      assert_equal "127.0.0.1", pantry_config.server_host
+      assert_equal 23001, pantry_config.pub_sub_port
+      assert_equal 23002, pantry_config.receive_port
+      assert_equal 23003, pantry_config.file_service_port
+    end
+  end
+
+  describe "Client-side Configuration" do
+    it "has an entry for client heartbeat interval" do
+      assert_equal 300, pantry_config.client_heartbeat_interval
+      pantry_config.client_heartbeat_interval = 5
+      assert_equal 5, pantry_config.client_heartbeat_interval
+    end
+
+    it "has an entry for the client's application" do
+      pantry_config.client_application = "pantry"
+      assert_equal "pantry", pantry_config.client_application
+    end
+
+    it "has an entry for the client's environment" do
+      pantry_config.client_environment = "pantry"
+      assert_equal "pantry", pantry_config.client_environment
+    end
+
+    it "has an entry for the client's identity" do
+      pantry_config.client_identity = "pantry"
+      assert_equal "pantry", pantry_config.client_identity
+    end
+
+    it "has an entry for the client's roles" do
+      pantry_config.client_roles = ["roles"]
+      assert_equal ["roles"], pantry_config.client_roles
+    end
+
+    it "can load values from a given YAML file" do
+      config_file = fixture_path("config.yml")
+      pantry_config.load_file(config_file)
+
+      assert_equal 600, pantry_config.client_heartbeat_interval
+      assert_equal "pantry-test-1", pantry_config.client_identity
+      assert_equal "pantry", pantry_config.client_application
+      assert_equal "test", pantry_config.client_environment
+      assert_equal %w(database application), pantry_config.client_roles
+    end
+
+    it "does not clobber certain values if config has set to nil" do
+      config_file = fixture_path("empty.yml")
+      pantry_config.load_file(config_file)
+
+      assert_equal 300, pantry_config.client_heartbeat_interval
+    end
+  end
+
+end