clamby 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d8a7e48c2bd0285d60fe7ece07fd72bca337e33fefb86d5304b6278132047d44
-  data.tar.gz: d2489bc3655ecf95667fa41f9aa39e104404fb9d0eccbbf5447dd6cd9e78b307
+  metadata.gz: 14e5489bd2c961059e2642dfcd7e472a838c449d114ba7ce7849eb4a7d8a2ae9
+  data.tar.gz: a0e7743a75f54442325af1773d923eb3ead7342efb6fd147733020c2ad85551b
 SHA512:
-  metadata.gz: 1a505ca85b244f599a0270a9e94e46305b1230fb2502eebbffbc441e86e78d7e668ab534fb39a2f086eb14a330c68706bd15104a387aec2e518108e9e4f912e3
-  data.tar.gz: 2401278d0d3721113268156994ed39eed440619b90f1e25dd42b62db99681eeeaa3aa23c9d5d7c7c59477ccd1875f93192f052a350ea9d83d3836517ec5ff724
+  metadata.gz: ec80ea427e309f396664d599e28e742ddbf1913f1f4c5a58e3be43557bd9ad0f85276827e58511d2132ce4c89e6ab577082d0e7dcc471dfea92cf3c08b448e44
+  data.tar.gz: '079f33a665afff1f99e6df4e8c6c7be877b5bade43d8d2fc4270976b77de7b84fc2cdeec8f1791c19b8c79b8ac921cd90e6974a448af0db6c96a2bac28601654'

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# v1.5.0
+ - Exceptions are now raised under Clamby module - could be breaking change
+ - [szajbus](https://github.com/kobaltz/clamby/commits?author=szajbus) fixed specs! and updated README
+ - [broder](https://github.com/kobaltz/clamby/commits?author=broder) added path for config file to address strange clamscan situations
+ - [tilsammans](https://github.com/kobaltz/clamby/commits?author=tilsammans) added queit, verbose and Command class
+
 # v1.4.0
  - [emilong](https://github.com/kobaltz/clamby/commits/master?author=emilong) added `:error_clamscan_client_error => false` option to prevent error from missing running daemon or clamscan.
 

data/README.md

@@ -66,32 +66,51 @@ It's good to note that Clamby will not by default delete files which had a virus
 
 # Configuration
 
-Configuration is rather limited right now. You can exclude the check if `clamscan` exists which will save a bunch of time for scanning your files. However, for development purposes, your machine may not have `clamscan` installed and you may wonder why it's not working properly. This is just to give you a reminder to install `clamscan` on your development machine and production machine. You can add the following to a config file, `clamby_setup.rb` to your initializers directory.
+Configuration is rather limited right now. You can exclude the check if `clamscan` exists which will save a bunch of time for scanning your files. However, for development purposes, your machine may not have `clamscan` installed and you may wonder why it's not working properly. This is just to give you a reminder to install `clamscan` on your development machine and production machine. You can add the following to an initializer, for example `config/initializers/clamby.rb`:
+
+```ruby
+    Clamby.configure({
+      :check => false,
+      :daemonize => false,
+      :config_file => nil,
+      :error_clamscan_missing => true,
+      :error_clamscan_client_error => false,
+      :error_file_missing => true,
+      :error_file_virus => false,
+      :fdpass => false,
+      :stream => false,
+      :output => 'medium' # one of 'off', 'low', 'medium', 'high'
+    })
+```
+
+#### Daemonize
+
+I highly recommend using the `daemonize` set to `true`. This will allow for clamscan to remain in memory and will not have to load for each virus scan. It will save several seconds per request.
+
+To specify a config file for clamdscan to use, you can set `config_file` with the relevant path. See [this page](https://linux.die.net/man/5/clamd.conf) for more information about the config file.
+
+#### Error suppression
 
 There has been added additional functionality where you can override exceptions. If you set the exceptions below to false, then there will not be a hard exception generated. Instead, it will post to your log that an error had occured. By default each one of these configuration options are set to true. You may want to set these to false in your production environment.
 
+#### Pass file descriptor permissions to clamd
+
 Setting the `fdpass` configuration option to `true` will pass the `--fdpass` option to clamscan. This might be useful if you are encountering permissions problems between clamscan and files being created by your application. From the clamscan man page:
 
 `--fdpass : Pass the file descriptor permissions to clamd. This is useful if clamd is running as a different user as it is faster than streaming the file to clamd. Only available if connected to clamd via local(unix) socket.`
 
+#### Force streaming files to clamd
+
 Setting the `stream` configuration option will stream the file to the daemon. This may be useful for forcing streaming as a test for local development. Only works when also specifying `daemonize`. From the clamdscan man page:
 
 `--stream : Forces file streaming to clamd. This is generally not needed as clamdscan detects automatically if streaming is required. This option only exists for debugging and testing purposes, in all other cases --fdpass is preferred.`
 
-```ruby
-    Clamby.configure({
-      :check => false,
-      :daemonize => false,
-      :error_clamscan_missing => false,
-      :error_file_missing => false,
-      :error_file_virus => false,
-      :fdpass => false,
-      :silence_output => false,
-      :stream => false
-    })
-```
+#### Output levels
 
-I highly recommend using the `daemonize` set to true. This will allow for clamscan to remain in memory and will not have to load for each virus scan. It will save several seconds per request.
+- *off*: suppress all output
+- *low*: show errors, but nothing else
+- *medium*: show errors and briefly what happened _(default)_
+- *high*: as verbose as possible
 
 # Dependencies
 
@@ -102,7 +121,7 @@ I highly recommend using the `daemonize` set to true. This will allow for clamsc
 Note, `clamav-daemon` is optional but recommended. It's needed if you wish to
 run ClamAV in daemon mode.
 
-***Apple***
+***macOS***
 
 `brew install clamav`
 

data/lib/clamby.rb

@@ -1,25 +1,38 @@
 require "English"
+require "clamby/command"
+require "clamby/error"
 require "clamby/version"
-require "clamby/exception"
+
 module Clamby
   DEFAULT_CONFIG = {
     :check => true,
     :daemonize => false,
+    :config_file => nil,
     :error_clamscan_missing => true,
     :error_clamscan_client_error => false,
     :error_file_missing => true,
     :error_file_virus => false,
     :fdpass => false,
-    :silence_output => false,
-    :stream => false
+    :stream => false,
+    :output_level => 'medium'
   }.freeze
 
   @config = DEFAULT_CONFIG.dup
 
   @valid_config_keys = @config.keys
 
+  class << self
+    attr_reader :config
+    attr_reader :valid_config_keys
+  end
+
   def self.configure(opts = {})
-    opts.each {|k,v| @config[k.to_sym] = v if @valid_config_keys.include? k.to_sym}
+    if opts.delete(:silence_output)
+      warn ':silence_output config is deprecated. Use :output_level => "off" instead.'
+      opts[:output_level] = 'off'
+    end
+
+    opts.each {|k,v| config[k.to_sym] = v if valid_config_keys.include? k.to_sym}
   end
 
   def self.safe?(path)
@@ -28,79 +41,26 @@ module Clamby
     ! value
   end
 
-  # Assemble the system command to be called, including optional flags
-  # @param [String] path path to the file being scanned
-  # @return [String] command to be executed
-  def self.system_command(path)
-    command = [].tap do |cmd|
-      cmd << clamd_executable_name
-      cmd << '--fdpass' if @config[:fdpass]
-      cmd << '--stream' if @config[:stream] && @config[:daemonize]
-      cmd << path
-      cmd << '--no-summary'
-      cmd << { out: File::NULL } if @config[:silence_output]
-    end
-    command
-  end
-
   def self.virus?(path)
     return nil unless scanner_exists?
-    return nil unless file_exists?(path)
-    system(*system_command(path))
-
-    case $CHILD_STATUS.exitstatus
-    when 0
-      return false
-    when 2
-      # clamdscan returns 2 whenever error other than a detection happens
-      if @config[:error_clamscan_client_error] && @config[:daemonize]
-        raise Exceptions::ClamscanClientError.new("Clamscan client error")
-      end
-
-      # returns true to maintain legacy behavior
-      return true
-    else
-      return true unless @config[:error_file_virus]
-
-      raise Exceptions::VirusDetected.new("VIRUS DETECTED on #{Time.now}: #{path}")
-    end
+    Command.scan path
   end
 
   def self.scanner_exists?
-    return true unless @config[:check]
-    scanner = system(clamd_executable_name, '-V', @config[:silence_output] ? { out: File::NULL } : {})
+    return true unless config[:check]
+    scanner = Command.clamscan_version
 
     return true if scanner
-    return false unless @config[:error_clamscan_missing]
-
-    raise Exceptions::ClamscanMissing.new("#{clamd_executable_name} application not found. Check your installation and path.")
-  end
-
-  def self.file_exists?(path)
-    return false if path.nil?
-    return true if File.file?(path)
+    return false unless config[:error_clamscan_missing]
 
-    if @config[:error_file_missing]
-      raise Exceptions::FileNotFound.new("File not found: #{path}")
-    else
-      puts "FILE NOT FOUND on #{Time.now}: #{path}"
-      return false
-    end
+    raise Clamby::ClamscanMissing.new("#{Command.scan_executable} not found. Check your installation and path.")
   end
 
   def self.update
-    system("freshclam", @config[:silence_output] ? { out: File::NULL } : {})
-  end
-
-  def self.config
-    @config
-  end
-
-  def self.clamd_executable_name(daemonize: false)
-    daemonize? ? "clamdscan" : "clamscan"
+    Command.freshclam
   end
 
   def self.daemonize?
-    !! @config[:daemonize]
+    !! config[:daemonize]
   end
 end

data/lib/clamby/command.rb

@@ -0,0 +1,102 @@
+module Clamby
+  # Interface with the system. Builds and runs the command.
+  class Command
+    EXECUTABLES = %w(clamscan clamdscan freshclam)
+
+    # Array containing the complete command line.
+    attr_accessor :command
+
+    # Returns the appropriate scan executable, based on clamd being used.
+    def self.scan_executable
+      return 'clamdscan' if Clamby.config[:daemonize]
+      return 'clamscan'
+    end
+
+    # Perform a ClamAV scan on the given path.
+    def self.scan(path)
+      return nil unless file_exists?(path)
+
+      args = [path, '--no-summary']
+
+      if Clamby.config[:daemonize]
+        args << '--fdpass' if Clamby.config[:fdpass]
+        args << '--stream' if Clamby.config[:stream]
+        args << "--config-file=#{Clamby.config[:config_file]}" if Clamby.config[:config_file] && Clamby.config[:daemonize]
+      end
+
+      new.run scan_executable, *args
+
+      case $CHILD_STATUS.exitstatus
+      when 0
+        return false
+      when 2
+        # clamdscan returns 2 whenever error other than a detection happens
+        if Clamby.config[:error_clamscan_client_error] && Clamby.config[:daemonize]
+          raise Clamby::ClamscanClientError.new("Clamscan client error")
+        end
+
+        # returns true to maintain legacy behavior
+        return true
+      else
+        return true unless Clamby.config[:error_file_virus]
+
+        raise Clamby::VirusDetected.new("VIRUS DETECTED on #{Time.now}: #{path}")
+      end
+    end
+
+    # Update the virus definitions.
+    def self.freshclam
+      new.run 'freshclam'
+    end
+
+    # Show the ClamAV version. Also acts as a quick check if ClamAV functions.
+    def self.clamscan_version
+      new.run 'clamscan', '--version'
+    end
+
+    # Run the given commands via a system call.
+    # The executable must be one of the permitted ClamAV executables.
+    # The arguments will be combined with default arguments if needed.
+    # The arguments are sorted alphabetically before being passed to the system.
+    #
+    # Examples:
+    #   run('clamscan', file, '--verbose')
+    #   run('clamscan', '-V')
+    def run(executable, *args)
+      raise "`#{executable}` is not permitted" unless EXECUTABLES.include?(executable)
+      self.command = args | default_args
+      self.command = command.sort.unshift(executable)
+
+      system(*self.command, system_options)
+    end
+
+    private
+
+    def default_args
+      args = []
+      args << '--quiet' if Clamby.config[:output_level] == 'low'
+      args << '--verbose' if Clamby.config[:output_level] == 'high'
+      args
+    end
+
+    # This applies to the `system` call itself; does not end up in the command.
+    def system_options
+      if Clamby.config[:output_level] == 'off'
+        { out: File::NULL }
+      else
+        {}
+      end
+    end
+
+    def self.file_exists?(path)
+      return true if File.file?(path)
+
+      if Clamby.config[:error_file_missing]
+        raise Clamby::FileNotFound.new("File not found: #{path}")
+      else
+        puts "FILE NOT FOUND on #{Time.now}: #{path}"
+        return false
+      end
+    end
+  end
+end

data/lib/clamby/{exception.rb → error.rb}

@@ -1,5 +1,6 @@
-module Exceptions
+module Clamby
   class Error < StandardError; end
+
   class VirusDetected < Error; end
   class ClamscanMissing < Error; end
   class ClamscanClientError < Error; end

data/lib/clamby/version.rb

@@ -1,3 +1,3 @@
 module Clamby
-  VERSION = "1.4.0"
+  VERSION = "1.5.0"
 end

data/spec/clamby/command_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+require 'support/shared_context'
+
+describe Clamby::Command do
+  before { Clamby.configure(Clamby::DEFAULT_CONFIG.dup) }
+
+  describe 'ClamAV version' do
+    it 'returns true' do
+      command = described_class.clamscan_version
+      expect(command).to be true
+    end
+  end
+
+  describe 'scan' do
+    include_context 'paths'
+
+    let(:runner){ instance_double(described_class) }
+
+    describe 'exceptions' do
+      it "can be configured to raise exception when file is missing" do
+        Clamby.configure({:error_file_missing => true})
+
+        expect do
+          described_class.scan(bad_path)
+        end.to raise_exception(Clamby::FileNotFound)
+      end
+      it 'can be configured to return nil when file is missing' do
+        Clamby.configure({:error_file_missing => false})
+        command = described_class.scan(bad_path)
+
+        expect(command).to be(nil)
+      end
+    end
+
+    describe 'passing file descriptor' do
+      it 'does not include fdpass in the command by default' do
+        Clamby.configure(fdpass: false)
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'omits the fdpass option when invoking clamscan if it is set, but daemonize isn\'t' do
+        Clamby.configure(fdpass: true)
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'passes the fdpass option when invoking clamscan if it is set with daemonize' do
+        Clamby.configure(fdpass: true, daemonize: true)
+        expect(runner).to receive(:run).with('clamdscan', good_path, '--no-summary', '--fdpass')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+    end
+
+    describe 'streaming files to clamd' do
+      it 'does not include stream in the command by default' do
+        Clamby.configure(stream: false)
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'omits the stream option when invoking clamscan if it is set, but daemonize isn\'t' do
+        Clamby.configure(stream: true)
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+
+      it 'passes the stream option when invoking clamscan if it is set with daemonize' do
+        Clamby.configure(stream: true, daemonize: true)
+        expect(runner).to receive(:run).with('clamdscan', good_path, '--no-summary', '--stream')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+    end
+
+    describe 'specifying config-file' do
+      it 'does not include the parameter in the clamscan command by default' do
+        Clamby.configure(daemonize: false, stream: false, fdpass: false)
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+      it 'does not include the parameter in the clamdscan command by default' do
+        Clamby.configure(daemonize: true, stream: false, fdpass: false)
+        expect(runner).to receive(:run).with('clamdscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+      it 'omits the parameter when invoking clamscan if it is set' do
+        Clamby.configure(daemonize: false, stream: false, fdpass: false, config_file: 'clamd.conf')
+        expect(runner).to receive(:run).with('clamscan', good_path, '--no-summary')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+      it 'passes the parameter when invoking clamdscan if it is set' do
+        Clamby.configure(daemonize: true, stream: false, fdpass: false, config_file: 'clamd.conf')
+        expect(runner).to receive(:run).with('clamdscan', good_path, '--no-summary', '--config-file=clamd.conf')
+        allow(described_class).to receive(:new).and_return(runner)
+
+        described_class.scan(good_path)
+      end
+    end
+  end
+end

data/spec/clamby_spec.rb

@@ -1,26 +1,15 @@
 require 'spec_helper'
-
-good_path = 'README.md'
-bad_path = 'BAD_FILE.md'
+require 'support/shared_context'
 
 describe Clamby do
-  before { Clamby.configure(Clamby::DEFAULT_CONFIG.dup) }
+  include_context 'paths'
 
-  it "should find files." do
-    expect(Clamby.file_exists?(good_path)).to be true
-  end
+  before { Clamby.configure(Clamby::DEFAULT_CONFIG.dup) }
 
   it "should find clamscan" do
     expect(Clamby.scanner_exists?).to be true
   end
 
-  it "should not find files." do
-    Clamby.configure({:error_file_missing => true})
-    expect{Clamby.file_exists?(bad_path)}.to raise_exception(Exceptions::FileNotFound)
-    Clamby.configure({:error_file_missing => false})
-    expect(Clamby.file_exists?(bad_path)).to be false
-  end
-
   it "should scan file as safe" do
     expect(Clamby.safe?(good_path)).to be true
     expect(Clamby.virus?(good_path)).to be false
@@ -33,21 +22,20 @@ describe Clamby do
   end
 
   it "should scan file as dangerous" do
-     `which wget`
-
-     if $?.success?
-      `wget http://www.eicar.org/download/eicar.com`
-     else
-      `curl http://www.eicar.org/download/eicar.com > eicar.com`
+    begin
+      file = download('https://secure.eicar.org/eicar.com')
+    rescue SocketError => error
+      pending("Skipped because reasons: #{error}")
     end
-    `chmod 644 eicar.com`
+
+    dangerous = file.path
     Clamby.configure({:error_file_virus => true})
-    expect{Clamby.safe?('eicar.com')}.to raise_exception(Exceptions::VirusDetected)
-    expect{Clamby.virus?('eicar.com')}.to raise_exception(Exceptions::VirusDetected)
+    expect{Clamby.safe?(dangerous)}.to raise_exception(Clamby::VirusDetected)
+    expect{Clamby.virus?(dangerous)}.to raise_exception(Clamby::VirusDetected)
     Clamby.configure({:error_file_virus => false})
-    expect(Clamby.safe?('eicar.com')).to be false
-    expect(Clamby.virus?('eicar.com')).to be true
-    File.delete('eicar.com')
+    expect(Clamby.safe?(dangerous)).to be false
+    expect(Clamby.virus?(dangerous)).to be true
+    File.delete(dangerous)
   end
 
   # From the clamscan man page:
@@ -62,14 +50,6 @@ describe Clamby do
       Clamby.configure(fdpass: true)
       expect(Clamby.config[:fdpass]).to eq true
     end
-    it 'does not include fdpass in the command by default' do
-      Clamby.configure(fdpass: false)
-      expect(Clamby.system_command(good_path)).to eq ["clamscan", good_path, "--no-summary"]
-    end
-    it 'passes the fdpass option when invoking clamscan if it is set' do
-      Clamby.configure(fdpass: true)
-      expect(Clamby.system_command(good_path)).to eq ["clamscan", "--fdpass", good_path, "--no-summary"]
-    end
   end
 
   # From the clamscan man page:
@@ -84,18 +64,6 @@ describe Clamby do
       Clamby.configure(stream: true)
       expect(Clamby.config[:stream]).to eq true
     end
-    it 'does not include stream in the command by default' do
-      Clamby.configure(stream: false)
-      expect(Clamby.system_command(good_path)).to eq ["clamscan", good_path, "--no-summary"]
-    end
-    it 'omits the stream option when invoking clamscan if it is set, but daemonize isn\'t' do
-      Clamby.configure(stream: true)
-      expect(Clamby.system_command(good_path)).to eq ["clamscan", good_path, "--no-summary"]
-    end
-    it 'passes the stream option when invoking clamscan if it is set with daemonize' do
-      Clamby.configure(stream: true, daemonize: true)
-      expect(Clamby.system_command(good_path)).to eq ["clamdscan", "--stream", good_path, "--no-summary"]
-    end
   end
 
   context 'error_clamscan_client_error option' do
@@ -131,7 +99,7 @@ describe Clamby do
 
       it 'virus? raises when the daemonized client exits with status 2' do
         Clamby.configure(daemonize: true)
-        expect { Clamby.virus?(good_path) }.to raise_error(Exceptions::ClamscanClientError)
+        expect { Clamby.virus?(good_path) }.to raise_error(Clamby::ClamscanClientError)
       end
       it 'returns true when the client exits with status 2' do
         Clamby.configure(daemonize: false)

data/spec/fixtures/safe.txt

@@ -0,0 +1,2 @@
+This is a virus-free file.
+It is used by automated tests.

data/spec/spec_helper.rb

@@ -1,8 +1,30 @@
 require 'bundler/setup'
 Bundler.setup
 
+require 'open-uri'
+require 'tempfile'
+
 require 'clamby' # and any other gems you need
 
 RSpec.configure do |config|
-  # some (optional) config here
-end
+  config.mock_with :rspec do |mocks|
+    # so that Command can keep doing what it always does.
+    mocks.verify_partial_doubles = true
+  end
+
+  def download(url)
+    file = open(url)
+    file.is_a?(StringIO) ? to_tempfile(file) : file
+  end
+
+  # OpenURI returns either Tempfile or StringIO depending of the size of
+  # the response. We want to unify this and always return Tempfile.
+  def to_tempfile(io)
+    tempfile = Tempfile.new('tmp')
+    tempfile.binmode
+    ::OpenURI::Meta.init(tempfile, io)
+    tempfile << io.string
+    tempfile.rewind
+    tempfile
+  end
+end

data/spec/support/shared_context.rb

@@ -0,0 +1,4 @@
+RSpec.shared_context 'paths' do
+  let(:good_path) { File.expand_path('../../fixtures/safe.txt', __FILE__) }
+  let(:bad_path) { File.expand_path("not-here/#{rand 10e6}.txt", __FILE__) }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clamby
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - kobaltz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-24 00:00:00.000000000 Z
+date: 2018-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -73,11 +73,15 @@ files:
 - clamby.gemspec
 - clamby_logo.png
 - lib/clamby.rb
-- lib/clamby/exception.rb
+- lib/clamby/command.rb
+- lib/clamby/error.rb
 - lib/clamby/version.rb
 - spec/.DS_Store
+- spec/clamby/command_spec.rb
 - spec/clamby_spec.rb
+- spec/fixtures/safe.txt
 - spec/spec_helper.rb
+- spec/support/shared_context.rb
 homepage: ''
 licenses:
 - MIT
@@ -98,11 +102,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: Scan file uploads with ClamAV
 test_files:
 - spec/.DS_Store
+- spec/clamby/command_spec.rb
 - spec/clamby_spec.rb
+- spec/fixtures/safe.txt
 - spec/spec_helper.rb
+- spec/support/shared_context.rb