How to spec a file download

Question

I am working on a library that needs to be able to download plugin files from a remote API using RestClient. The library first grabs a list of plugins, and then downloads each plugin as a raw file, saving each inside a plugins directory.

Here is what I have thus far but it is failing me:

require 'yaml'

module Monitaur
  class Client

    attr_accessor :logger, :client_key, :server_url, :config, :raw_config,
                  :plugin_manifest

    def initialize
      load_config
      @plugin_manifest ||= []
    end

    def run
      get_plugin_manifest
      sync_plugins
    end

    def get_plugin_manifest
      res = RestClient.get("#{server_url}/nodes/#{client_key}/plugins")
      @plugin_manifest = JSON.parse(res)
    end

    def sync_plugins
      @plugin_manifest.each do |plugin|
        res = RestClient.get("#{server_url}/plugins/#{plugin['name']}")
        File.open(File.join(Monitaur.plugin_dir, "#{plugin['name']}.rb"), "w+") do |file|
          file.write res.body
        end
      end
    end

    def load_config
      if File.exist?(Monitaur.config_file_path) && File.readable?(Monitaur.config_file_path)
        @raw_config = YAML.load_file(Monitaur.config_file_path)
      else
        raise IOError, "Cannot open or read #{Monitaur.config_file_path}"
      end

      @server_url = raw_config['server_url']
      @client_key = raw_config['client_key']
    end


  end
end

And the client_spec.rb

require 'spec_helper'

module Monitaur
  describe Client do
    let(:server_url) { "http://api.monitaurapp.com" }
    let(:client_key) { "asdf1234" }

    describe "#load_config" do
      let(:client) { Monitaur::Client.new }

      before do
        File.open(Monitaur.config_file_path, "w") do |file|
          file.puts "server_url: http://api.monitaurapp.com"
          file.puts "client_key: asdf1234"
        end 
      end

      it "loads up the configuration file" do
        client.load_config
        client.server_url.should == "http://api.monitaurapp.com"
        client.client_key.should == "asdf1234"
      end
    end

    describe "#get_plugin_manifest" do
      let(:client) { Monitaur::Client.new }

      before do
        stub_get_plugin_manifest
      end

      it "retrieves a plugins manifest from the server" do
        client.get_plugin_manifest
        client.plugin_manifest.should == plugin_manifest_response
      end
    end

    describe "#sync_plugins" do
      let(:client) { Monitaur::Client.new }
      let(:foo_plugin) { mock('foo_plugin') }
      let(:bar_plugin) { mock('bar_plugin') }

      before do
        FileUtils.mkdir("/tmp")
        File.open("/tmp/foo_plugin.rb", "w+") do |file|
          file.write %|
          class FooPlugin < Monitaur::Plugin
            name "foo_plugin"
            desc "A test plugin to determine whether plugin sync works"

            def run
              { :foo => 'foo' }
            end
          end
          |
        end
        File.open("/tmp/bar_plugin.rb", "w+") do |file|
          file.write %|
          class BarPlugin < Monitaur::Plugin
            name "bar_plugin"
            desc "A test plugin to determine whether plugin sync works"

            def run
              { :bar => 'bar' }
            end
          end
          |
        end
        Monitaur.install
        stub_get_plugin_manifest
        stub_sync_plugins
        client.get_plugin_manifest

      end

      it "downloads plugins to the cache directory" do
        File.should_receive(:open).
          with(File.join(Monitaur.plugin_dir, "foo_plugin.rb"), "w+")
          and_yield(foo_plugin)

        client.sync_plugins

        File.exist?("/home/user/.monitaur/cache/plugins/foo_plugin.rb").should be_true
        File.exist?("/home/user/.monitaur/cache/plugins/bar_plugin.rb").should be_true
      end
    end
  end
end

def stub_get_plugin_manifest
  stub_request(:get, "#{server_url}/nodes/#{client_key}/plugins").
    to_return(
      :status => 200,
      :body => %Q{
        [
          {
            "name": "foo_plugin",
            "checksum": "qwer5678"
          },
          {
            "name": "bar_plugin",
            "checksum": "hjkl4321"
          }
        ]
      }
    )
end

def plugin_manifest_response
  [
    {
      "name" => "foo_plugin",
      "checksum" => "qwer5678"
    },
    {
      "name" => "bar_plugin",
      "checksum" => "hjkl4321"
    }
  ]
end

def stub_sync_plugins
  stub_request(:get, "#{server_url}/plugins/foo_plugin").
    to_return(:body => File.open('/tmp/foo_plugin.rb').read)

  stub_request(:get, "#{server_url}/plugins/bar_plugin").
    to_return(:body => File.open('/tmp/bar_plugin.rb').read)
end

How can I test the download process?

Answer 1

I use FakeWeb for this purpose, as there's really no need for your spec to fail if the other site is down or something. See "Replaying a recorded response" in the docs. What we do is curl the page, save it somewhere as a fixture and replay that in the specs.