nightcrawler_swift 0.4.0 → 0.5.0

data/spec/lib/nightcrawler_swift/cli/opt_parser_spec.rb

@@ -0,0 +1,135 @@
+require "spec_helper"
+require "nightcrawler_swift/cli"
+
+describe NightcrawlerSwift::CLI::OptParser do
+
+  let :runner do
+    instance_double "Runner", options: OpenStruct.new(bucket: nil, config_file: nil, default_config_file: true)
+  end
+
+  let :config_dir do
+    File.expand_path(File.join(File.dirname(__FILE__), "../../../fixtures"))
+  end
+
+  subject do
+    NightcrawlerSwift::CLI::OptParser.new runner
+  end
+
+  describe "options" do
+
+    ["-v", "--version"].each do |switch|
+      context switch do
+        it "prints the version number" do
+          allow(runner).to receive(:argv).and_return([switch])
+          expect(runner).to receive(:log).with(NightcrawlerSwift::VERSION)
+          expect { subject.parse! }.to raise_error SystemExit
+        end
+      end
+    end
+
+    ["-h", "--help"].each do |switch|
+      context switch do
+        it "prints the help" do
+          allow(runner).to receive(:argv).and_return([switch])
+          expect(runner).to receive(:log).with(subject.help)
+          expect { subject.parse! }.to raise_error SystemExit
+        end
+      end
+    end
+
+    ["-c PATH", "--config=PATH"].each do |switch|
+      context switch do
+        let :config_file do
+          File.join(config_dir, "#{NightcrawlerSwift::CLI::CONFIG_FILE}-test")
+        end
+
+        let :command do
+          switch.gsub(/PATH/, config_file)
+        end
+
+        before do
+          File.open(config_file, "w") {|f| f.write("test")}
+        end
+
+        after do
+          File.delete(config_file) if File.exist?(config_file)
+        end
+
+        it "configures the config_file" do
+          allow(runner).to receive(:log)
+          allow(runner).to receive(:argv).and_return([command])
+          subject.parse!
+          expect(runner.options.config_file).to eql config_file
+          expect(runner.options.default_config_file).to eql false
+        end
+
+        context "when the config file does not exist" do
+          let :invalid_filename do
+            "invalid-file"
+          end
+
+          let :invalid_filepath do
+            File.expand_path(File.join(File.dirname(__FILE__), "../../../../", invalid_filename))
+          end
+
+          let :command do
+            switch.gsub(/PATH/, invalid_filename)
+          end
+
+          it "prints the error and exit with a failure" do
+            expect(runner).to receive(:argv).and_return([command])
+            expect(runner).to receive(:log).with("Error: No such file or directory - #{invalid_filepath}")
+            exited = false
+
+            begin
+              subject.parse!
+            rescue SystemExit => e
+              exited = true
+              expect(e.status).to eql 1
+            ensure
+              expect(exited).to eql true
+            end
+          end
+        end
+      end
+    end
+
+    ["-b NAME", "--bucket=NAME"].each do |switch|
+      context switch do
+        let :bucket_name do
+          "rogue"
+        end
+
+        let :command do
+          switch.gsub(/NAME/, bucket_name)
+        end
+
+        it "configures the bucket name" do
+          allow(runner).to receive(:argv).and_return([command])
+          allow(runner).to receive(:log)
+          subject.parse!
+          expect(runner.options.bucket).to eql bucket_name
+        end
+      end
+    end
+  end
+
+  describe "#parse!" do
+    before do
+      allow(runner).to receive(:argv).and_return([])
+    end
+
+    it "calls method 'parse!' in OptionParser with runner argv" do
+      expect(subject.parser).to receive(:parse!).with(runner.argv)
+      subject.parse!
+    end
+  end
+
+  describe "#help" do
+    it "calls method 'help' in OptionParser" do
+      expect(subject.parser).to receive(:help)
+      subject.help
+    end
+  end
+
+end

data/spec/lib/nightcrawler_swift/{cli_spec.rb → cli/runner_spec.rb}

@@ -1,10 +1,10 @@
 require "spec_helper"
 require "nightcrawler_swift/cli"
 
-describe NightcrawlerSwift::CLI do
+describe NightcrawlerSwift::CLI::Runner do
 
   let :config_dir do
-    File.expand_path(File.join(File.dirname(__FILE__), "../../fixtures"))
+    File.expand_path(File.join(File.dirname(__FILE__), "../../../fixtures"))
   end
 
   let :config_file do
@@ -16,7 +16,15 @@ describe NightcrawlerSwift::CLI do
   end
 
   let :connection_success_json do
-    JSON.parse File.read(File.join(File.dirname(__FILE__), "../..", "fixtures/auth_success.json"))
+    JSON.parse File.read(File.join(config_dir, "auth_success.json"))
+  end
+
+  let :formatter do
+    NightcrawlerSwift::CLI::Formatters::Basic.new(subject)
+  end
+
+  let :filepath do
+    "testfile.txt"
   end
 
   let :opts do
@@ -30,11 +38,12 @@ describe NightcrawlerSwift::CLI do
   end
 
   subject do
-    NightcrawlerSwift::CLI.new argv.dup
+    NightcrawlerSwift::CLI::Runner.new argv.dup
   end
 
   before do
-    allow(subject).to receive(:user_home_dir).and_return(config_dir)
+    allow(Dir).to receive(:home).and_return(config_dir)
+    allow(NightcrawlerSwift::CLI::Formatters::Basic).to receive(:new).and_return(formatter)
   end
 
   after do
@@ -61,66 +70,6 @@ describe NightcrawlerSwift::CLI do
     end
   end
 
-  shared_examples "CLI with parsed parameters" do
-    context "--version or -v" do
-      it "prints the version number" do
-        subject.argv << "-v"
-        expect(subject).to receive(:log).with(NightcrawlerSwift::VERSION)
-        expect { subject.run }.to raise_error SystemExit
-
-        expect(subject).to receive(:log).with(NightcrawlerSwift::VERSION)
-        subject.argv = (argv << "--version")
-        expect { subject.run }.to raise_error SystemExit
-      end
-    end
-
-    context "--help or -h" do
-      before do
-        subject.send :configure_default_options
-        subject.send :configure_opt_parser
-
-        allow(subject).to receive(:configure_default_options)
-        allow(subject).to receive(:configure_opt_parser)
-      end
-
-      it "prints the help" do
-        subject.argv << "-h"
-        expect(subject).to receive(:log).with(subject.opt_parser.help)
-        expect { subject.run }.to raise_error SystemExit
-
-        expect(subject).to receive(:log).with(subject.opt_parser.help)
-        subject.argv = (argv << "--help")
-        expect { subject.run }.to raise_error SystemExit
-      end
-    end
-
-    context "--config or -c" do
-      let :config_file do
-        File.join(config_dir, "#{NightcrawlerSwift::CLI::CONFIG_FILE}-test")
-      end
-
-      before do
-        allow(subject).to receive(:execute_command)
-        allow(subject).to receive(:log)
-        File.open(config_file, "w") {|f| f.write("test")}
-      end
-
-      after do
-        File.delete(config_file) if File.exist?(config_file)
-      end
-
-      it "configures the config_file" do
-        subject.argv << "-c #{config_file}"
-        subject.run
-        expect(subject.options.config_file).to eql config_file
-
-        subject.argv = (argv << "--config=#{config_file}")
-        subject.run
-        expect(subject.options.config_file).to eql config_file
-      end
-    end
-  end
-
   shared_examples "CLI that creates a sample config file" do
     before do
       allow(subject).to receive(:execute_command)
@@ -131,7 +80,7 @@ describe NightcrawlerSwift::CLI do
       expect(File.exist?(config_file)).to eql false
       expect { subject.run }.to raise_error SystemExit
       expect(File.exist?(config_file)).to eql true
-      expect(File.read(config_file)).to eql subject.send(:sample_rcfile)
+      expect(File.read(config_file)).to eql NightcrawlerSwift::CLI.sample_rcfile
     end
 
     it "flags as not configured" do
@@ -146,7 +95,7 @@ describe NightcrawlerSwift::CLI do
     end
 
     before do
-      allow(subject).to receive(command_method)
+      allow(formatter).to receive(command_method)
       allow(NightcrawlerSwift).to receive(:connection).and_return(connection)
       File.open(config_file, "w") {|f| f.write(opts.to_json)}
     end
@@ -167,6 +116,21 @@ describe NightcrawlerSwift::CLI do
       end
     end
 
+    context "with a custom bucket name" do
+      let(:bucket_name) { "rogue" }
+
+      before do
+        subject.send :configure_default_options
+        expect(subject.options.bucket).to be_nil
+      end
+
+      it "overrides the default name" do
+        allow(subject).to receive(:parse_parameters) { subject.options.bucket = bucket_name }
+        subject.run
+        expect(NightcrawlerSwift.options.bucket).to eql bucket_name
+      end
+    end
+
     it "writes the auth_response into cache file" do
       expect(File.exist?(cache_file)).to eql false
       expect(connection).to receive(:auth_response).and_return(OpenStruct.new(connection_success_json))
@@ -174,120 +138,153 @@ describe NightcrawlerSwift::CLI do
       expect(File.exist?(cache_file)).to eql true
       expect(File.read(cache_file)).to eql connection_success_json.to_json
     end
+
+    context "when rescue NightcrawlerSwift::Exceptions::BaseError" do
+      let(:message) { "error" }
+
+      before do
+        NightcrawlerSwift.logger = Logger.new(StringIO.new)
+      end
+
+      it "prints the error and exit with failure" do
+        expect(subject).to receive(:connect_and_execute).and_raise(NightcrawlerSwift::Exceptions::BaseError.new(message))
+        exited = false
+
+        begin
+          subject.run
+        rescue SystemExit => e
+          exited = true
+          expect(e.status).to eql 1
+        ensure
+          expect(exited).to eql true
+        end
+      end
+    end
+
+    context "when rescue Errno::ENOENT" do
+      before do
+        NightcrawlerSwift.logger = Logger.new(StringIO.new)
+      end
+
+      it "prints the error and exit with failure" do
+        expect(subject).to receive(:connect_and_execute).and_raise(Errno::ENOENT.new)
+        exited = false
+
+        begin
+          subject.run
+        rescue SystemExit => e
+          exited = true
+          expect(e.status).to eql 1
+        ensure
+          expect(exited).to eql true
+        end
+      end
+    end
   end
 
   describe "command list" do
     let(:argv) { ["list"] }
     let(:command) { NightcrawlerSwift::List.new }
     let(:command_method) { :command_list }
-    let :result do
-      [{
-        "hash"=>"c9df50d4a29542f8b6d426a50c72b3de",
-        "last_modified"=>"2014-08-27T19:35:46.053560",
-        "bytes"=>4994,
-        "name"=>"assets/file.png",
-        "content_type"=>"image/png"
-      }]
-    end
 
     it_behaves_like "CLI with default options"
-    it_behaves_like "CLI with parsed parameters"
     it_behaves_like "CLI that creates a sample config file"
     it_behaves_like "CLI that uses the configured command"
-
-    context "when executing the command" do
-      before do
-        File.open(config_file, "w") {|f| f.write(opts.to_json)}
-      end
-
-      it "lists all files in the bucket/container configured" do
-        expect(NightcrawlerSwift::List).to receive(:new).and_return(command)
-        expect(command).to receive(:execute).and_return(result)
-        expect(subject).to receive(:log).with(result.first["name"])
-        subject.run
-      end
-    end
   end
 
   describe "command download" do
-    let(:filepath) { "testfile.txt" }
     let(:argv) { ["download", filepath] }
     let(:command) { NightcrawlerSwift::Download.new }
     let(:command_method) { :command_download }
 
     it_behaves_like "CLI with default options"
-    it_behaves_like "CLI with parsed parameters"
     it_behaves_like "CLI that creates a sample config file"
     it_behaves_like "CLI that uses the configured command"
-
-    context "when executing the command" do
-      before do
-        File.open(config_file, "w") {|f| f.write(opts.to_json)}
-      end
-
-      it "downloads the file" do
-        expect(NightcrawlerSwift::Download).to receive(:new).and_return(command)
-        expect(command).to receive(:execute).with(filepath).and_return("test-content")
-        expect(subject).to receive(:log).with("test-content")
-        subject.run
-      end
-    end
   end
 
   describe "command upload" do
-    let(:swiftpath) { "testfile.txt" }
-    let(:realpath) { File.join(config_dir, swiftpath) }
-    let(:argv) { ["upload", realpath, swiftpath] }
+    let(:realpath) { File.join(config_dir, filepath) }
+    let(:argv) { ["upload", realpath, filepath] }
     let(:command) { NightcrawlerSwift::Upload.new }
     let(:command_method) { :command_upload }
 
     it_behaves_like "CLI with default options"
-    it_behaves_like "CLI with parsed parameters"
     it_behaves_like "CLI that creates a sample config file"
     it_behaves_like "CLI that uses the configured command"
-
-    context "when executing the command" do
-      before do
-        File.open(config_file, "w") {|f| f.write(opts.to_json)}
-        File.open(realpath, "w") {|f| f.write("test") }
-      end
-
-      after do
-        File.delete(realpath) if File.exist?(realpath)
-      end
-
-      it "uploads the file" do
-        expect(NightcrawlerSwift::Upload).to receive(:new).and_return(command)
-        expect(command).to receive(:execute).with(swiftpath, instance_of(File)).and_return(true)
-        expect(subject).to receive(:log).with("success")
-        subject.run
-      end
-    end
   end
 
   describe "command delete" do
-    let(:filepath) { "testfile.txt" }
     let(:argv) { ["delete", filepath] }
     let(:command) { NightcrawlerSwift::Delete.new }
     let(:command_method) { :command_delete }
 
     it_behaves_like "CLI with default options"
-    it_behaves_like "CLI with parsed parameters"
     it_behaves_like "CLI that creates a sample config file"
     it_behaves_like "CLI that uses the configured command"
+  end
+
+  describe "command delete" do
+    let(:argv) { ["url-for", filepath] }
+    let(:command) { NightcrawlerSwift::CLI::UrlFor.new }
+    let(:command_method) { :command_url_for }
+
+    it_behaves_like "CLI with default options"
+    it_behaves_like "CLI that creates a sample config file"
+    it_behaves_like "CLI that uses the configured command"
+  end
+
+  describe "validation of commands" do
+    context "when no command is provided" do
+      let(:argv) { [] }
 
-    context "when executing the command" do
       before do
-        File.open(config_file, "w") {|f| f.write(opts.to_json)}
+        subject.send :configure_default_options
+        subject.send :configure_opt_parser
       end
 
-      it "downloads the file" do
-        expect(NightcrawlerSwift::Delete).to receive(:new).and_return(command)
-        expect(command).to receive(:execute).with(filepath).and_return(true)
-        expect(subject).to receive(:log).with("success")
-        subject.run
+      it "prints the help and exit with success" do
+        exited = false
+        expect(subject).to receive(:log).with(subject.opt_parser.help)
+        begin
+          subject.run
+        rescue SystemExit => e
+          exited = true
+          expect(e.status).to eql 0
+        ensure
+          expect(exited).to eql true
+        end
+      end
+    end
+
+    context "when the command does not exist" do
+      let(:argv) { ["wrong"] }
+
+      it "prints the error and exit with failure" do
+        exited = false
+        expect(subject).to receive(:log).with("Error: Unknown command 'wrong'")
+        begin
+          subject.run
+        rescue SystemExit => e
+          exited = true
+          expect(e.status).to eql 1
+        ensure
+          expect(exited).to eql true
+        end
       end
     end
   end
 
+  describe "#log" do
+    let(:argv) { [] }
+
+    before do
+      NightcrawlerSwift.logger = Logger.new(StringIO.new)
+    end
+
+    it "uses NightcrawlerSwift.logger" do
+      expect(NightcrawlerSwift).to receive(:logger).and_call_original
+      subject.log "stuff"
+    end
+  end
+
 end

data/spec/lib/nightcrawler_swift/command_spec.rb

@@ -17,21 +17,14 @@ describe NightcrawlerSwift::Command do
   let(:connection) { NightcrawlerSwift::Connection.new }
   let(:restclient) { double(:restclient, put: response, get: response, delete: response) }
   let(:response) { double(:response) }
-  let(:url) { "http://url.com" }
+  let(:url) { "http://url-com" }
   let(:token) { "token" }
   let(:expires_at) { (DateTime.now + 60).to_time }
 
-  shared_examples "resource configured with NightcrawlerSwift.options" do
-    it "uses the configured verify_ssl" do
-      NightcrawlerSwift.configure verify_ssl: true
+  shared_examples "command with configured gateway" do
+    it "creates a new gateway with the url" do
+      expect(NightcrawlerSwift::Gateway).to receive(:new).with(url).and_call_original
       execute_http
-      expect(RestClient::Resource).to have_received(:new).with(url, hash_including(verify_ssl: true))
-    end
-
-    it "uses the configured timeout" do
-      NightcrawlerSwift.configure timeout: 10
-      execute_http
-      expect(RestClient::Resource).to have_received(:new).with(url, hash_including(timeout: 10))
     end
   end
 
@@ -66,67 +59,59 @@ describe NightcrawlerSwift::Command do
   end
 
   describe "#get" do
-    let :get do
+    let :execute_http do
       subject.send :get, url, headers: {content_type: :json}
     end
 
-    let(:execute_http) { get }
-    it_behaves_like "resource configured with NightcrawlerSwift.options"
+    it_behaves_like "command with configured gateway"
 
     it "sends headers with token" do
-      get
+      execute_http
       expect(restclient).to have_received(:get).with(content_type: :json, "X-Storage-Token" => token)
     end
 
     it "returns RestClient response" do
-      expect(get).to eql(response)
+      expect(execute_http).to eql(response)
     end
   end
 
   describe "#delete" do
-    let :delete do
+    let :execute_http do
       subject.send :delete, url, headers: {content_type: :json}
     end
 
-    let(:execute_http) { delete }
-    it_behaves_like "resource configured with NightcrawlerSwift.options"
+    it_behaves_like "command with configured gateway"
 
     it "sends headers with token" do
-      delete
+      execute_http
       expect(restclient).to have_received(:delete).with(content_type: :json, "X-Storage-Token" => token)
     end
 
     it "returns RestClient response" do
-      expect(delete).to eql(response)
+      expect(execute_http).to eql(response)
     end
   end
 
   describe "#put" do
-    let :put do
+    let :execute_http do
       subject.send(:put, url, body: 'content', headers: {a: 1})
     end
 
-    let(:execute_http) { put }
-    it_behaves_like "resource configured with NightcrawlerSwift.options"
+    it_behaves_like "command with configured gateway"
 
     it "returns RestClient response" do
-      expect(put).to eql(response)
+      expect(execute_http).to eql(response)
     end
 
     it "sends body" do
-      put
+      execute_http
       expect(restclient).to have_received(:put).with('content', anything)
     end
 
     it "sends headers with token" do
-      put
+      execute_http
       expect(restclient).to have_received(:put).with(anything, {a: 1, "X-Storage-Token" => token})
     end
-
-    it "uses url to initialize RestClient" do
-      put
-      expect(RestClient::Resource).to have_received(:new).with(url, verify_ssl: false, timeout: nil)
-    end
   end
 
 end

data/spec/lib/nightcrawler_swift/commands/delete_spec.rb

@@ -23,15 +23,15 @@ describe NightcrawlerSwift::Delete do
       subject.execute "file_path"
     end
 
-    before do
-      allow(subject).to receive(:delete).and_return(response)
-    end
-
     context "success" do
       let :response do
         double(:response, code: 200)
       end
 
+      before do
+        allow(subject).to receive(:delete).and_return(response)
+      end
+
       it "deletes using upload url" do
         execute
         expect(subject).to have_received(:delete).with("server-url/file_path", headers: {accept: :json})
@@ -42,31 +42,10 @@ describe NightcrawlerSwift::Delete do
       end
     end
 
-    context "when the file does not exist" do
-      let :response do
-        double(:response, code: 404)
-      end
-
-      before do
-        allow(subject).to receive(:delete).and_raise(RestClient::ResourceNotFound.new(response))
-      end
-
-      it "raises NightcrawlerSwift::Exceptions::NotFoundError" do
-        expect { execute }.to raise_error NightcrawlerSwift::Exceptions::NotFoundError
-      end
-    end
-
-    context "when another error happens" do
-      let :response do
-        double(:response, code: 500)
-      end
-
-      before do
-        allow(subject).to receive(:delete).and_raise(RuntimeError.new(response))
-      end
-
-      it "raises NightcrawlerSwift::Exceptions::ConnectionError" do
-        expect { execute }.to raise_error NightcrawlerSwift::Exceptions::ConnectionError
+    context "when the path was not informed" do
+      it "raises NightcrawlerSwift::Exceptions::ValidationError" do
+        expect { subject.execute nil }.to raise_error NightcrawlerSwift::Exceptions::ValidationError
+        expect { subject.execute "" }.to raise_error NightcrawlerSwift::Exceptions::ValidationError
       end
     end
   end