pantry 0.0.0 → 0.1.0

data/test/unit/command_handler_test.rb

@@ -0,0 +1,79 @@
+require 'unit/test_helper'
+
+describe Pantry::CommandHandler do
+
+  let(:client)          { Pantry::Client.new(identity: "Test Client") }
+  let(:command_handler) { Pantry::CommandHandler.new(client) }
+
+  class TestMessage < Pantry::Command
+    def perform(message)
+      "Test message ran #{message.uuid}"
+    end
+  end
+
+  it "executes commands that match the message type" do
+    message = Pantry::Message.new("TestMessage")
+
+    command_handler.add_command(TestMessage)
+    output = command_handler.process(message)
+
+    assert_equal "Test message ran #{message.uuid}", output
+  end
+
+  it "ignores messages that don't match any command" do
+    message = Pantry::Message.new("message_type")
+    assert_nil command_handler.process(message)
+  end
+
+  it "knows if it can process a given command or not" do
+    command_handler.add_command(TestMessage)
+
+    message = Pantry::Message.new("unknown_type")
+    assert_false command_handler.can_handle?(message), "Should not be able to handle unknown_type"
+
+    message = Pantry::Message.new("TestMessage")
+    assert command_handler.can_handle?(message), "Should be able to handle TestMessage"
+  end
+
+  class ReturnClientIdentity < Pantry::Command
+    def perform(message)
+      self.client.identity
+    end
+  end
+
+  it "sets the server or client on the command before it's performed" do
+    message = Pantry::Message.new("ReturnClientIdentity")
+
+    command_handler.add_command(ReturnClientIdentity)
+    response = command_handler.process(message)
+
+    assert_equal "Test Client", response
+  end
+
+  class ReturnMessageIdentity < Pantry::Command
+    def perform(message)
+      message
+    end
+  end
+
+  it "sets the server or client on the command before it's performed" do
+    message = Pantry::Message.new("ReturnMessageIdentity")
+
+    command_handler.add_command(ReturnMessageIdentity)
+    response = command_handler.process(message)
+
+    assert_equal message, response
+  end
+
+  it "can take a list of command classes on construction to handle" do
+    handler = Pantry::CommandHandler.new(
+      client, [TestMessage, ReturnClientIdentity, ReturnMessageIdentity])
+
+    assert handler.can_handle?(Pantry::Message.new("TestMessage")),
+      "Did not register TestMessage"
+    assert handler.can_handle?(Pantry::Message.new("ReturnClientIdentity")),
+      "Did not register ReturnClientIdentity"
+    assert handler.can_handle?(Pantry::Message.new("ReturnMessageIdentity")),
+      "Did not register ReturnMessageIdentity"
+  end
+end

data/test/unit/command_line_test.rb

@@ -0,0 +1,5 @@
+require 'unit/test_helper'
+
+describe Pantry::CommandLine do
+
+end

data/test/unit/command_test.rb

@@ -0,0 +1,206 @@
+require 'unit/test_helper'
+
+describe Pantry::Command do
+
+  it "creates a message from itself" do
+    command = Pantry::Command.new
+    message = command.to_message
+
+    assert_equal "Command", message.type
+  end
+
+  it "has a link back to the Server or Client handling the command" do
+    command = Pantry::Command.new
+    command.server_or_client = "client"
+
+    assert_equal "client", command.server
+    assert_equal "client", command.client
+  end
+
+  it "can prepare itself as a Message to be sent down the pipe" do
+    command = Pantry::Command.new
+    message = command.prepare_message({})
+
+    assert message.is_a?(Pantry::Message),
+      "prepare_message returned the wrong value"
+  end
+
+  describe "Response Handling" do
+    describe "#receive_server_response" do
+      class ServerCommand < Pantry::Command
+        attr_reader :server_response
+        def receive_server_response(response)
+          @server_response = response
+        end
+      end
+
+      before do
+        @message = Pantry::Message.new
+        @message.from = Pantry::SERVER_IDENTITY
+
+        @command = ServerCommand.new
+        @command.receive_response(@message)
+      end
+
+      it "is triggered by a non-client-list server message" do
+        assert_equal @message, @command.server_response,
+          "Did not triger the server response handler"
+      end
+
+      it "marks the command as finished" do
+        assert @command.finished?
+      end
+    end
+
+    describe "#receive_client_response" do
+      let(:server_message) do
+        Pantry::Message.new.tap do |sm|
+          sm.from = Pantry::SERVER_IDENTITY
+          sm[:client_response_list] = true
+          sm << "client1"
+          sm << "client2"
+        end
+      end
+
+      class ClientCommand < Pantry::Command
+        attr_reader :client_responses
+        def receive_client_response(response)
+          @client_responses ||= []
+          @client_responses << response
+        end
+      end
+
+      it "does not forward Server client_list message" do
+        command = ClientCommand.new
+        command.receive_response(server_message)
+
+        assert_nil command.client_responses,
+          "Should not have forwarded server client list message"
+      end
+
+      it "is triggered by Client responses" do
+        client_message = Pantry::Message.new
+        client_message.from = "client1"
+
+        command = ClientCommand.new
+        command.receive_response(client_message)
+
+        assert_equal [client_message], command.client_responses,
+          "Did not forward the client message to the handler"
+      end
+
+      it "does not mark the command as finished" do
+        client_message = Pantry::Message.new
+        client_message.from = "client1"
+
+        command = ClientCommand.new
+        command.receive_response(client_message)
+
+        assert !command.finished?, "Command was improperly marked as finished"
+      end
+
+      it "marks the command as finished if all Clients have responded" do
+        c1 = Pantry::Message.new
+        c1.from = "client1"
+        c2 = Pantry::Message.new
+        c2.from = "client2"
+
+        command = ClientCommand.new
+        command.receive_response(server_message)
+        command.receive_response(c1)
+        command.receive_response(c2)
+
+        assert_equal [c1, c2], command.client_responses
+        assert command.finished?, "Command was not marked as finished after all responses"
+      end
+    end
+  end
+
+  module Pantry
+    module Commands
+      class SubCommand < Pantry::Command
+      end
+    end
+  end
+
+  module Pantry
+    module MyStuff
+      class SubCommand < Pantry::Command
+      end
+    end
+  end
+
+  it "cleans up any known Pantry scoping when figuring out message type" do
+    assert_equal "SubCommand", Pantry::Commands::SubCommand.message_type
+    assert_equal "MyStuff::SubCommand", Pantry::MyStuff::SubCommand.message_type
+  end
+
+  module John
+    module Pete
+      class InnerClass < Pantry::Command
+      end
+    end
+  end
+
+  it "uses the full scoped name of the class" do
+    command = John::Pete::InnerClass.new
+    message = command.to_message
+
+    assert_equal "John::Pete::InnerClass", message.type
+  end
+
+  class CustomNameCommand < Pantry::Command
+    def self.message_type
+      "Gir::WantsWaffles"
+    end
+  end
+
+  it "allows custom command types" do
+    command = CustomNameCommand.new
+    message = command.to_message
+
+    assert_equal "Gir::WantsWaffles", message.type
+  end
+
+  describe "#send_request!" do
+    it "can send a request out and wait for the response" do
+      client = Pantry::Client.new
+      command = Pantry::Command.new
+      command.client = client
+      message = Pantry::Message.new
+      response = Pantry::Message.new
+
+      client.expects(:send_request).with(message).returns(mock(:value => response))
+
+      assert_equal response, command.send_request!(message)
+    end
+  end
+
+  describe "#send_request" do
+    it "can send a request and return the future for async waiting" do
+      client = Pantry::Client.new
+      command = Pantry::Command.new
+      command.client = client
+      message = Pantry::Message.new
+
+      client.expects(:send_request).with(message).returns("future")
+
+      assert_equal "future", command.send_request(message)
+    end
+  end
+
+  describe "CLI" do
+
+    class CLICommand < Pantry::Command
+      command "cli" do
+        description "Sloppy"
+      end
+    end
+
+    it "can configure CLI options and information" do
+      assert_equal "cli", CLICommand.command_name
+      assert_not_nil CLICommand.command_config, "No command config found"
+    end
+
+  end
+end

data/test/unit/commands/create_client_test.rb

@@ -0,0 +1,25 @@
+require 'unit/test_helper'
+
+describe Pantry::Commands::CreateClient do
+
+  mock_ui!
+
+  it "asks server for a new set of encryption keys" do
+    server = Pantry::Server.new
+
+    command = Pantry::Commands::CreateClient.new
+    command.server = server
+    server.expects(:create_client).returns(
+      server_public_key: "server public key",
+      public_key:  "client public",
+      private_key: "client private"
+    )
+
+    keys = command.perform(Pantry::Message.new)
+
+    assert_equal "server public key", keys[:server_public_key]
+    assert_equal "client public", keys[:public_key]
+    assert_equal "client private", keys[:private_key]
+  end
+
+end

data/test/unit/commands/download_directory_test.rb

@@ -0,0 +1,58 @@
+require 'unit/test_helper'
+
+describe Pantry::Commands::DownloadDirectory do
+
+  fake_fs!
+
+  it "builds a message with the given directory" do
+    message = Pantry::Commands::DownloadDirectory.new("path/here").to_message
+    assert_equal "path/here", message.body[0]
+  end
+
+  it "returns filename and contents of all files inside of the requested directory" do
+    root_dir = Pantry
+    message = Pantry::Message.new
+    message << "copy/from"
+
+    FileUtils.mkdir_p(Pantry.root.join("copy", "from"))
+    FileUtils.touch(Pantry.root.join("copy", "from", "app.rb"))
+    FileUtils.touch(Pantry.root.join("copy", "from", "db.rb"))
+
+    command = Pantry::Commands::DownloadDirectory.new
+    response = command.perform(message)
+
+    assert_equal 2, response.length
+    assert_equal ["app.rb", ""], response[0]
+    assert_equal ["db.rb", ""], response[1]
+  end
+
+  it "does nested read of the given directory" do
+    root_dir = Pantry
+    message = Pantry::Message.new
+    message << "copy/from"
+
+    FileUtils.mkdir_p(Pantry.root.join("copy", "from", "here", "there"))
+    FileUtils.touch(Pantry.root.join("copy", "from", "here", "there", "app.rb"))
+    FileUtils.touch(Pantry.root.join("copy", "from", "here", "there", "db.rb"))
+
+    command = Pantry::Commands::DownloadDirectory.new
+    response = command.perform(message)
+
+    assert_equal 2, response.length
+    assert_equal ["here/there/app.rb", ""], response[0]
+    assert_equal ["here/there/db.rb", ""], response[1]
+  end
+
+  it "does not allow path traversal attacks" do
+    root_dir = Pantry
+    message = Pantry::Message.new
+    message << "../../../../etc/"
+
+    command = Pantry::Commands::DownloadDirectory.new
+    response = command.perform(message)
+
+    assert_equal 0, response.length
+  end
+
+end
+

data/test/unit/commands/echo_test.rb

@@ -0,0 +1,22 @@
+require 'unit/test_helper'
+
+describe Pantry::Commands::Echo do
+
+  it "returns the body of the message received" do
+    message = Pantry::Message.new("Echo")
+    message << "This is a body"
+
+    command = Pantry::Commands::Echo.new
+    results = command.perform(message)
+
+    assert_equal "This is a body", results
+  end
+
+  it "creates a message with the requested string" do
+    command = Pantry::Commands::Echo.new("Hello World")
+    message = command.to_message
+
+    assert_equal "Hello World", message.body[0]
+  end
+
+end

data/test/unit/commands/edit_application_test.rb

@@ -0,0 +1,84 @@
+require 'unit/test_helper'
+
+describe Pantry::Commands::EditApplication do
+  let(:command) { Pantry::Commands::EditApplication.new }
+
+  fake_fs!
+
+  describe "#prepare_message" do
+    it "requires an application" do
+      assert_raises(Pantry::MissingOption) do
+        command.prepare_message({})
+      end
+    end
+
+    it "puts the application requested in the message" do
+      message = command.prepare_message({application: "pantry"})
+      assert_equal "pantry", message.body[0]
+    end
+  end
+
+  describe "#perform" do
+    let(:edit_message) do
+      Pantry::Message.new.tap do |msg|
+        msg << "pantry"
+      end
+    end
+
+    it "returns the configuration of the given application" do
+      config_file = Pantry.root.join("applications", "pantry", "config.yml")
+      FileUtils.mkdir_p(File.dirname(config_file))
+      File.open(config_file, "w+") do |f|
+        f.write({"some" => "config"}.to_yaml)
+      end
+
+      response = command.perform(edit_message)
+      assert_equal "---\nsome: config\n", response[0]
+    end
+
+    it "returns a new YAML config if no file exist for the application" do
+      response = command.perform(edit_message)
+      assert_equal "---\nname: pantry\n", response[0]
+    end
+  end
+
+  describe "#receive_response" do
+    it "lets the user edit the file and uploads when successful" do
+      orig_config_body = {name: "pantry"}.to_yaml
+      new_config_body = {name: "pantry", config: false}.to_yaml
+
+      response = Pantry::Message.new
+      response.from = Pantry::SERVER_IDENTITY
+      response << orig_config_body
+
+      Pantry::FileEditor.any_instance.expects(:edit).
+        with(orig_config_body, :yaml).returns(new_config_body)
+
+      command.expects(:send_request!).with do |message|
+        assert_equal "pantry", message.body[0]
+        assert_equal new_config_body, message.body[1]
+      end
+
+      command.prepare_message({application: "pantry"})
+      command.receive_response(response)
+
+      assert command.finished?, "Command was not finished"
+    end
+
+    it "doesn't send the Update command if file contents did not change" do
+      config_body = {name: "pantry"}.to_yaml
+
+      response = Pantry::Message.new
+      response.from = Pantry::SERVER_IDENTITY
+      response << config_body
+
+      Pantry::FileEditor.any_instance.expects(:edit).returns(config_body)
+
+      command.expects(:send_request!).never
+
+      command.prepare_message({application: "pantry"})
+      command.receive_response(response)
+    end
+  end
+
+end