mc_dump 0.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTYxNjg3MjBmMDI2N2M4NTQwNzY2MWQ0YzlhZDJlNTIxZmRkY2NjNA==
+  data.tar.gz: !binary |-
+    YzcyODBhODJmMjk0NTMyZWZjYTQ5MzQ3NzdkZTdkM2QzZTIxNWVjMQ==
+SHA512:
+  metadata.gz: !binary |-
+    NmI0Y2RlNjA3MTk2ZDdmOTVkMTQ5MWVkZDZkZTA5YTY1MDdmYzY0MTFlMDJi
+    MTI4NjVlMTRlNjlkYjk1MTczNzM1NTAzMjE5N2I0YTlmMDNhYzliYTU5ODA5
+    YzI4YzM2ZGQ0NzE2NzU5YzQ4MGQwYzc0OGE4MzZiZWU2OTBkYTY=
+  data.tar.gz: !binary |-
+    ZTRmMWUzYWIxNTk3NWJjZGJkZjc5ODE1YzVmYWEwNzBiNjA1OGU3YTVkNGE5
+    NGM5OGFmMDY4NDM5NGJmMmM5NzkzNTg5YTYxZjJkOTVmN2NkMjhmMjdjN2Rj
+    Y2Y4MjE3MDZmYWRlMmUxMWJmNTBmNzc4MzRhZjE1NDkxMGM5MmU=

data/lib/mc_dump/memcached/item.rb

@@ -0,0 +1,29 @@
+module McDump
+  module Memcached
+
+    class Item
+
+      def self.parse(dump, items_id)
+        dump.scan(/^ITEM (.+?) \[(\d+) b; (\d+) s\]$/).map do |item_data|
+          cache_key, size_in_bytes, expires_string = item_data
+          self.new(
+            items_id:        items_id,
+            cache_key:       cache_key,
+            expiration_time: Time.at(expires_string.to_i),
+            size_in_bytes:   size_in_bytes.to_i
+          )
+        end
+      end
+
+      def initialize(args)
+        @data = args
+      end
+
+      def to_h
+        @data.clone
+      end
+
+    end
+
+  end
+end

data/lib/mc_dump/memcached/server.rb

@@ -0,0 +1,20 @@
+module McDump
+  module Memcached
+
+    class Server
+
+      def initialize(connection_args)
+        @connection_args = connection_args
+      end
+
+      def items
+        McDump::Telnet::Session.open(@connection_args) do |session|
+          item_stats = McDump::Memcached::Stat.parse(session.stats)
+          item_stats.map { |stat| stat.items(session) }.flatten
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mc_dump/memcached/stat.rb

@@ -0,0 +1,24 @@
+module McDump
+  module Memcached
+
+    class Stat
+
+      def self.parse(dump)
+        dump.scan(/STAT items:(\d+):number (\d+)/).map do |data|
+          self.new(items_id: data[0], number: data[1])
+        end
+      end
+
+      def initialize(args)
+        @items_id = args[:items_id]
+        @number   = args[:number]
+      end
+
+      def items(telnet_session)
+        McDump::Memcached::Item.parse(telnet_session.items(@items_id, @number), @items_id)
+      end
+
+    end
+
+  end
+end

data/lib/mc_dump/rake/task.rb

@@ -0,0 +1,20 @@
+module McDump
+  module Rake
+
+    class Task < ::Rake::TaskLib
+
+      def initialize(name, connection_args)
+        desc "Dumps contents of a memcached instance, supports arguments: host, port, timeout_in_seconds"
+        task(name) do
+          McDump.server({
+            host:               ENV["host"],
+            port:               ENV["port"],
+            timeout_in_seconds: ENV["timeout_in_seconds"]
+          }.merge(connection_args))
+        end
+      end
+
+    end
+
+  end
+end

data/lib/mc_dump/report.rb

@@ -0,0 +1,31 @@
+module McDump
+
+  class Report
+
+    def initialize(items)
+      @items = items
+    end
+
+    def dump(io=$stdout)
+      column_size_metadata = determine_column_size_metadata
+      column_names         = column_size_metadata.keys
+      line_format = "|#{column_names.map { |name| " %#{column_size_metadata[name]}s " }.join("|")}|"
+      io.puts line_format % column_names
+      @items.each { |item| io.puts line_format % item.to_h.values_at(*column_names) }
+    end
+
+    private
+
+    def determine_column_size_metadata
+      @items.reduce({}) do |size_metadata, item|
+        item.to_h.each do |data_key, data_value|
+          size_metadata[data_key] ||= data_key.to_s.length
+          size_metadata[data_key]   = [ data_value.to_s.length, size_metadata[data_key] ].max
+        end
+        size_metadata
+      end
+    end
+
+  end
+
+end

data/lib/mc_dump/telnet/connection.rb

@@ -0,0 +1,25 @@
+module McDump
+  module Telnet
+
+    class Connection
+
+      def initialize(args)
+        @telnet = Net::Telnet::new(
+          "Host"    => args[:host],
+          "Port"    => args[:port],
+          "Timeout" => args[:timeout_in_seconds] || 5
+        )
+      end
+
+      def execute(string)
+        @telnet.cmd("String" => string, "Match" => /^END/)
+      end
+
+      def close
+        @telnet.close
+      end
+
+    end
+
+  end
+end

data/lib/mc_dump/telnet/session.rb

@@ -0,0 +1,30 @@
+module McDump
+  module Telnet
+
+    class Session
+
+      def self.open(connection_args, &block)
+        session = self.new(connection_args)
+        block.call(session).tap { session.close }
+      end
+
+      def initialize(connection_args)
+        @connection = McDump::Telnet::Connection.new(connection_args)
+      end
+
+      def stats
+        @connection.execute("stats items")
+      end
+
+      def items(id, number)
+        @connection.execute("stats cachedump #{id} #{number}")
+      end
+
+      def close
+        @connection.close
+      end
+
+    end
+
+  end
+end

data/lib/mc_dump/version.rb

@@ -0,0 +1,3 @@
+module McDump
+  VERSION = "0.0.0".freeze
+end

data/lib/mc_dump.rb

@@ -0,0 +1,17 @@
+require 'net/telnet'
+
+require_relative 'mc_dump/telnet/connection'
+require_relative 'mc_dump/telnet/session'
+require_relative 'mc_dump/memcached/item'
+require_relative 'mc_dump/memcached/stat'
+require_relative 'mc_dump/memcached/server'
+require_relative 'mc_dump/report'
+
+module McDump
+
+  def self.server(connection_args)
+    server = McDump::Memcached::Server.new(connection_args)
+    McDump::Report.new(server.items).dump
+  end
+
+end

data/spec/lib/mc_dump/memcached/item_spec.rb

@@ -0,0 +1,111 @@
+describe McDump::Memcached::Item do
+
+  let(:items_id)        { "8" }
+  let(:cache_key)       { SecureRandom.uuid }
+  let(:expiration_time) { "1447214865" }
+  let(:size_in_bytes)   { 321 }
+
+  let(:args) do
+    {
+      items_id:        items_id,
+      cache_key:       cache_key,
+      expiration_time: expiration_time,
+      size_in_bytes:   size_in_bytes
+    }
+  end
+
+  let(:item) { described_class.new(args) }
+
+  describe "::parse" do
+
+    subject { described_class.parse(dump, items_id) }
+
+    context "when the dump contains many lines" do
+
+      let(:dump) do
+        <<-DUMP
+ITEM namespace:fc7c3121-30c9-478c-9662-99f8b9df8931 [407 b; 1447214865 s]
+ITEM namespace:e81bbb97-d679-4cea-80c2-787950256083 [392 b; 1447214866 s]
+ITEM namespace:f5ed8536-1265-486a-afbf-73a26828a0ce [413 b; 1447214867 s]
+        DUMP
+      end
+
+      it "creates an item for each line containing the line cache keys" do
+        expected_cache_keys = %w{
+          namespace:fc7c3121-30c9-478c-9662-99f8b9df8931
+          namespace:e81bbb97-d679-4cea-80c2-787950256083
+          namespace:f5ed8536-1265-486a-afbf-73a26828a0ce
+        }
+        expected_cache_keys.each do |expected_cache_key|
+          expect(described_class).to receive(:new).with(hash_including(cache_key: expected_cache_key))
+        end
+
+        subject
+      end
+
+      it "creates an item for each line containing the line expiration times converted to Time" do
+        expected_expiration_times = %w{ 1447214865 1447214866 1447214867 }
+        expected_expiration_times.each do |expected_expiration_time|
+          expectation_as_time = Time.at(expected_expiration_time.to_i)
+          expect(described_class).to receive(:new).with(hash_including(expiration_time: expectation_as_time))
+        end
+
+        subject
+      end
+
+      it "creates an item for each line containing the line sizes in bytes" do
+        expected_sizes_in_bytes = [ 407, 392, 413 ]
+        expected_sizes_in_bytes.each do |expected_size_in_bytes|
+          expect(described_class).to receive(:new).with(hash_including(size_in_bytes: expected_size_in_bytes))
+        end
+
+        subject
+      end
+
+      it "creates an item for each line containing the provided items ID" do
+        expect(described_class).to receive(:new).with(hash_including(items_id: items_id)).exactly(3).times
+
+        subject
+      end
+
+      it "returns the created items" do
+        items = (1..3).map { instance_double(described_class) }
+        allow(described_class).to receive(:new).and_return(*items)
+
+        expect(subject).to eql(items)
+      end
+
+    end
+
+    context "when the dump is empty" do
+
+      let(:dump) { "" }
+
+      it "returns an empty array" do
+        expect(subject).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#to_h" do
+
+    subject { item.to_h }
+
+    it "returns a hash containing the provided arguments" do
+      expect(subject).to eql(args)
+    end
+
+    it "returns a copy of the provided arguments" do
+      original_cache_key = cache_key
+
+      hash = subject
+      args[:cache_key] = "modified cache key"
+
+      expect(hash[:cache_key]).to eql(original_cache_key)
+    end
+
+  end
+
+end

data/spec/lib/mc_dump/memcached/server_spec.rb

@@ -0,0 +1,52 @@
+describe McDump::Memcached::Server do
+
+  let(:connection_args) { { host: "some.host", port: 12345 } }
+
+  let(:server) { described_class.new(connection_args) }
+
+  describe "#items" do
+
+    let(:stats_dump)     { "some stats dump" }
+    let(:items)          { (1..3).map { (1..3).map { instance_double(McDump::Memcached::Item) } } }
+    let(:stats)          { (1..3).map { instance_double(McDump::Memcached::Stat) } }
+    let(:telnet_session) { instance_double(McDump::Telnet::Session, stats: stats_dump) }
+
+    subject { server.items }
+
+    before(:example) do
+      allow(McDump::Telnet::Session).to receive(:open).and_yield(telnet_session)
+      allow(McDump::Memcached::Stat).to receive(:parse).and_return(stats)
+      stats.zip(items) { |stat, items| allow(stat).to receive(:items).and_return(items) }
+    end
+
+    it "opens a telnet session using the provided connection arguments" do
+      expect(McDump::Telnet::Session).to receive(:open).with(connection_args)
+
+      subject
+    end
+
+    it "retrieves the stats via the Memcached telnet session" do
+      expect(telnet_session).to receive(:stats)
+
+      subject
+    end
+
+    it "parses the stats" do
+      expect(McDump::Memcached::Stat).to receive(:parse).with(stats_dump)
+
+      subject
+    end
+
+    it "retrieves the items for each stat" do
+      stats.each { |stat| expect(stat).to receive(:items).with(telnet_session) }
+
+      subject
+    end
+
+    it "returns all the items" do
+      expect(subject).to eql(items.flatten)
+    end
+
+  end
+
+end

data/spec/lib/mc_dump/memcached/stat_spec.rb

@@ -0,0 +1,118 @@
+describe McDump::Memcached::Stat do
+
+  let(:items_id) { 8 }
+  let(:number)   { 21 }
+
+  let(:stat) { described_class.new(items_id: items_id, number: number) }
+
+  describe "::parse" do
+
+    subject { described_class.parse(dump) }
+
+    context "when the dump contains many items" do
+
+      let(:dump) do
+        <<-DUMP
+STAT items:9:number 19
+STAT items:9:age 876543
+STAT items:9:evicted 0
+STAT items:9:evicted_nonzero 0
+STAT items:9:evicted_time 0
+STAT items:9:outofmemory 0
+STAT items:9:tailrepairs 0
+STAT items:9:reclaimed 3
+STAT items:9:expired_unfetched 2
+STAT items:9:evicted_unfetched 0
+STAT items:9:crawler_reclaimed 0
+STAT items:9:crawler_items_checked 0
+STAT items:9:lrutail_reflocked 0
+STAT items:10:number 20
+STAT items:10:age 123456
+STAT items:10:evicted 0
+STAT items:10:evicted_nonzero 0
+STAT items:10:evicted_time 0
+STAT items:10:outofmemory 0
+STAT items:10:tailrepairs 0
+STAT items:10:reclaimed 6
+STAT items:10:expired_unfetched 8
+STAT items:10:evicted_unfetched 0
+STAT items:10:crawler_reclaimed 0
+STAT items:10:crawler_items_checked 0
+STAT items:10:lrutail_reflocked 0
+STAT items:11:number 21
+STAT items:11:age 975319
+STAT items:11:evicted 0
+STAT items:11:evicted_nonzero 0
+STAT items:11:evicted_time 0
+STAT items:11:outofmemory 0
+STAT items:11:tailrepairs 0
+STAT items:11:reclaimed 1
+STAT items:11:expired_unfetched 10
+STAT items:11:evicted_unfetched 0
+STAT items:11:crawler_reclaimed 0
+STAT items:11:crawler_items_checked 0
+STAT items:11:lrutail_reflocked 0
+        DUMP
+      end
+
+      it "creates a stat for each item entry containing the number of entries in the cache" do
+        stats_arg_expectations = [
+          { items_id: "9", number: "19" }, { items_id: "10", number: "20" }, { items_id: "11", number: "21" }
+        ]
+        stats_arg_expectations.each { |expectation| expect(described_class).to receive(:new).with(expectation) }
+
+        subject
+      end
+
+      it "returns the stats" do
+        stats = (1..3).map { instance_double(described_class) }
+        allow(described_class).to receive(:new).and_return(*stats)
+
+        expect(subject).to eql(stats)
+      end
+
+    end
+
+    context "when the dump is empty" do
+
+      let(:dump) { "" }
+
+      it "returns an empty array" do
+        expect(subject).to eql([])
+      end
+
+    end
+
+  end
+
+  describe "#items" do
+
+    let(:items_dump)      { "some items data" }
+    let(:telnet_session) { instance_double(McDump::Telnet::Session, items: items_dump) }
+
+    subject { stat.items(telnet_session) }
+
+    before(:example) { allow(telnet_session).to receive(:items).and_return(items_dump) }
+
+    it "determines the items in the memcached instance via the telnet session" do
+      expect(telnet_session).to receive(:items).with(items_id, number)
+
+      subject
+    end
+
+    it "parses the items returned via telnet" do
+      expect(McDump::Memcached::Item).to receive(:parse).with(items_dump, items_id)
+
+      subject
+    end
+
+    it "returns the parsed items" do
+      items = (1..3).map { instance_double(McDump::Memcached::Item) }
+      allow(McDump::Memcached::Item).to receive(:parse).and_return(items)
+
+      expect(subject).to eql(items)
+    end
+
+  end
+
+end

data/spec/lib/mc_dump/rake/task_spec.rb

@@ -0,0 +1,73 @@
+describe McDump::Rake::Task do
+
+  describe "constructor" do
+
+    let(:name)               { :some_dump_task }
+    let(:host)               { "some.host" }
+    let(:port)               { "12345" }
+    let(:timeout_in_seconds) { "10" }
+    let(:connection_args)    { {} }
+
+    subject { described_class.new(name, connection_args) }
+
+    after(:example) { ::Rake::Task[name].clear }
+
+    it "creates a rake task with the provided name" do
+      subject
+
+      expect(::Rake::Task.task_defined?(name)).to be(true)
+    end
+
+    describe "the created rake task" do
+
+      subject do
+        described_class.new(name, connection_args)
+
+        ::Rake::Task[name].execute
+      end
+
+      context "when connection arguments are provided" do
+
+        let(:connection_args) { { host: host, port: port, timeout_in_seconds: timeout_in_seconds } }
+
+        it "dumps a server identified by the provided connection arguments" do
+          expect(McDump).to receive(:server).with(connection_args)
+
+          subject
+        end
+
+      end
+
+      context "when no connection arguments are provided" do
+
+        let(:connection_args) { {} }
+
+        before(:example) do
+          @original_env_host               = ENV["host"]
+          @original_env_port               = ENV["port"]
+          @original_env_timeout_in_seconds = ENV["timeout_in_seconds"]
+
+          ENV["host"]               = host
+          ENV["port"]               = port
+          ENV["timeout_in_seconds"] = timeout_in_seconds
+        end
+
+        after(:example) do
+          ENV["host"]               = @original_env_host
+          ENV["port"]               = @original_env_port
+          ENV["timeout_in_seconds"] = @original_env_timeout_in_seconds
+        end
+
+        it "dumps a server identified by environment variables host, port and timeout_in_seconds" do
+          expect(McDump).to receive(:server).with(host: host, port: port, timeout_in_seconds: timeout_in_seconds)
+
+          subject
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/mc_dump/report_spec.rb

@@ -0,0 +1,61 @@
+describe McDump::Report do
+
+  let(:report) { described_class.new(items) }
+
+  describe "#dump" do
+
+    let(:io)     { StringIO.new }
+    let(:output) { io.string }
+
+    subject { report.dump(io) }
+
+    context "when multiple items are provided" do
+
+      let(:base_time) { Time.new(2015, 11, 17, 12, 0, 0, "+10:00") }
+
+      let(:items) do
+        (1..3).map do |i|
+          McDump::Memcached::Item.new(
+            items_id: "#{i}",
+            cache_key: "some long cache key #{i}",
+            expiration_time: base_time + i,
+            size_in_bytes: i * 1024)
+        end
+      end
+
+      it "outputs a header row containing each column header spaced to display values" do
+        expected_header_row = "| items_id |             cache_key |           expiration_time | size_in_bytes |"
+
+        subject
+
+        expect(output).to start_with(expected_header_row)
+      end
+
+      it "outputs a data row for each item" do
+        expected_data_rows =
+          "|        1 | some long cache key 1 | 2015-11-17 12:00:01 +1000 |          1024 |\n" +
+          "|        2 | some long cache key 2 | 2015-11-17 12:00:02 +1000 |          2048 |\n" +
+          "|        3 | some long cache key 3 | 2015-11-17 12:00:03 +1000 |          3072 |"
+
+        subject
+
+        expect(output).to include(expected_data_rows)
+      end
+
+    end
+
+    context "when no items are provided" do
+
+      let(:items) { [] }
+
+      it "outputs an empty header row" do
+        subject
+
+        expect(output).to eql("||\n")
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/mc_dump/telnet/connection_spec.rb

@@ -0,0 +1,88 @@
+describe McDump::Telnet::Connection do
+
+  let(:host)            { "some.host" }
+  let(:port)            { 12345 }
+  let(:additional_args) { {} }
+  let(:args)            { { host: host, port: port }.merge(additional_args) }
+  let(:telnet)          { instance_double(Net::Telnet) }
+
+  let(:connection) { described_class.new(args) }
+
+  before(:example) { allow(Net::Telnet).to receive(:new).and_return(telnet) }
+
+  describe "constructor" do
+
+    subject { connection }
+
+    it "creates a telnet instance with the provided host and port" do
+      expect(Net::Telnet).to receive(:new).with(hash_including("Host" => host, "Port" => port))
+
+      subject
+    end
+
+    context "when a connection timeout is provided" do
+
+      let(:timeout_in_seconds) { 8 }
+      let(:additional_args)    { { timeout_in_seconds: timeout_in_seconds } }
+
+      it "creates a telnet instance with the provided timeout in seconds" do
+        expect(Net::Telnet).to receive(:new).with(hash_including("Timeout" => timeout_in_seconds))
+
+        subject
+      end
+
+    end
+
+    context "when a connection timeout is not provided" do
+
+      let(:additional_args) { {} }
+
+      it "defaults the timeout to 5 seconds" do
+        expect(Net::Telnet).to receive(:new).with(hash_including("Timeout" => 5))
+
+        subject
+      end
+
+    end
+
+  end
+
+  describe "#execute" do
+
+    let(:command) { "some command" }
+
+    subject { connection.execute(command) }
+
+    it "sends the provided command string to the underlying telnet instance" do
+      expect(telnet).to receive(:cmd).with(hash_including("String" => command))
+
+      subject
+    end
+
+    it "concludes awaiting output when END is observed in the stream" do
+      expect(telnet).to receive(:cmd).with(hash_including("Match" => /^END/))
+
+      subject
+    end
+
+    it "returns the result of the command" do
+      allow(telnet).to receive(:cmd).and_return("some command result")
+
+      expect(subject).to eql("some command result")
+    end
+
+  end
+
+  describe "#close" do
+
+    subject { connection.close }
+
+    it "closes the underlying telnet instance" do
+      expect(telnet).to receive(:close)
+
+      subject
+    end
+
+  end
+
+end

data/spec/lib/mc_dump/telnet/session_spec.rb

@@ -0,0 +1,109 @@
+describe McDump::Telnet::Session do
+
+  let(:connection_args) { { host: "some.host", port: 12345 } }
+  let(:connection)      { instance_double(McDump::Telnet::Connection) }
+
+  let(:session) { described_class.new(connection_args) }
+
+  before(:example) { allow(McDump::Telnet::Connection).to receive(:new).and_return(connection) }
+
+  describe "::open" do
+
+    let(:open_block_result) { "some open block result"}
+    let(:open_block)        { lambda { |session| open_block_result } }
+    let(:session)           { instance_double(described_class, close: nil) }
+
+    subject { described_class.open(connection_args, &open_block) }
+
+    before(:example) { allow(described_class).to receive(:new).and_return(session) }
+
+    it "creates a session with the provided connection settings" do
+      expect(described_class).to receive(:new).with(connection_args)
+
+      subject
+    end
+
+    it "invokes the provided block with the created session" do
+      expect(open_block).to receive(:call).with(session)
+
+      subject
+    end
+
+    it "closes the created session" do
+      expect(session).to receive(:close)
+
+      subject
+    end
+
+    it "returns the result of the block" do
+      expect(subject).to eql(open_block_result)
+    end
+
+  end
+
+  describe "constructor" do
+
+    subject { session }
+
+    it "opens a connection using the provided connection settings" do
+      expect(McDump::Telnet::Connection).to receive(:new).with(connection_args)
+
+      subject
+    end
+
+  end
+
+  describe "#stats" do
+
+    subject { session.stats }
+
+    it "executes a command on the connection to retrieve the stats for items" do
+      expect(connection).to receive(:execute).with("stats items")
+
+      subject
+    end
+
+    it "returns the commands response" do
+      response = (1..3).map { |i| "STAT line #{i}" }
+      allow(connection).to receive(:execute).and_return(response)
+
+      expect(subject).to eql(response)
+    end
+
+  end
+
+  describe "#items" do
+
+    let(:id)     { 12 }
+    let(:number) { 987 }
+
+    subject { session.items(id, number) }
+
+    it "executes a command on the connection showing the number of items matching the id" do
+      expect(connection).to receive(:execute).with("stats cachedump #{id} #{number}")
+
+      subject
+    end
+
+    it "returns the commands response" do
+      response = (1..3).map { |i| "ITEM line #{i}" }
+      allow(connection).to receive(:execute).and_return(response)
+
+      expect(subject).to eql(response)
+    end
+
+  end
+
+  describe "#close" do
+
+    subject { session.close }
+
+    it "closes the telnet connection that was made when the session was created" do
+      expect(connection).to receive(:close)
+
+      subject
+    end
+
+  end
+
+end

data/spec/lib/mc_dump_spec.rb

@@ -0,0 +1,43 @@
+describe McDump do
+
+  describe "::server" do
+
+    let(:connection_args) { { host: "some.host", port: 12345 } }
+    let(:items)           { (1..3).map { instance_double(McDump::Memcached::Item) } }
+    let(:server)          { instance_double(McDump::Memcached::Server, items: items) }
+    let(:report)          { instance_double(McDump::Report, dump: nil) }
+
+    subject { described_class.server(connection_args) }
+
+    before(:example) do
+      allow(McDump::Memcached::Server).to receive(:new).and_return(server)
+      allow(McDump::Report).to receive(:new).and_return(report)
+    end
+
+    it "creates a server" do
+      expect(McDump::Memcached::Server).to receive(:new).with(connection_args)
+
+      subject
+    end
+
+    it "retrieves all items from the server" do
+      expect(server).to receive(:items)
+
+      subject
+    end
+
+    it "creates a report containing the items" do
+      expect(McDump::Report).to receive(:new).with(items)
+
+      subject
+    end
+
+    it "dumps the contents of the report" do
+      expect(report).to receive(:dump)
+
+      subject
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'bundler'
+Bundler.require(:development)
+
+CodeClimate::TestReporter.start
+
+SimpleCov.start do
+  coverage_dir "tmp/coverage"
+
+  add_filter "/spec/"
+
+  minimum_coverage 100
+  refuse_coverage_drop
+end if ENV["coverage"]
+
+require 'rake/tasklib'
+
+require_relative '../lib/mc_dump'
+require_relative '../lib/mc_dump/rake/task'

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: mc_dump
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Matthew Ueckerman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-11-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: travis-lint
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: metric_fu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.12'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: coderay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+description: Dumps key values pairs within a memcached instance.  Useful for verification
+  of cached content.
+email: matthew.ueckerman@myob.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ./lib/mc_dump.rb
+- ./lib/mc_dump/memcached/item.rb
+- ./lib/mc_dump/memcached/server.rb
+- ./lib/mc_dump/memcached/stat.rb
+- ./lib/mc_dump/rake/task.rb
+- ./lib/mc_dump/report.rb
+- ./lib/mc_dump/telnet/connection.rb
+- ./lib/mc_dump/telnet/session.rb
+- ./lib/mc_dump/version.rb
+- ./spec/lib/mc_dump/memcached/item_spec.rb
+- ./spec/lib/mc_dump/memcached/server_spec.rb
+- ./spec/lib/mc_dump/memcached/stat_spec.rb
+- ./spec/lib/mc_dump/rake/task_spec.rb
+- ./spec/lib/mc_dump/report_spec.rb
+- ./spec/lib/mc_dump/telnet/connection_spec.rb
+- ./spec/lib/mc_dump/telnet/session_spec.rb
+- ./spec/lib/mc_dump_spec.rb
+- ./spec/spec_helper.rb
+homepage: http://github.com/MYOB-Technology/mc_dump
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: Dumps the contents of a memcached instance
+test_files:
+- ./spec/lib/mc_dump/memcached/item_spec.rb
+- ./spec/lib/mc_dump/memcached/server_spec.rb
+- ./spec/lib/mc_dump/memcached/stat_spec.rb
+- ./spec/lib/mc_dump/rake/task_spec.rb
+- ./spec/lib/mc_dump/report_spec.rb
+- ./spec/lib/mc_dump/telnet/connection_spec.rb
+- ./spec/lib/mc_dump/telnet/session_spec.rb
+- ./spec/lib/mc_dump_spec.rb
+- ./spec/spec_helper.rb