conjur-cli 4.14.0 → 4.15.0

data/spec/command/audit_spec.rb

@@ -4,7 +4,7 @@ describe Conjur::Command::Audit, logged_in: true do
   let(:events) { [{'foo' => 'bar', 'zelda' => 'link', 'abc' => 'xyz'}, {'some' => 'other event'}] }
 
   def expect_api_call method, *args
-    api.should_receive(method.to_sym).with(*args).and_return events
+    expect(api).to receive(method.to_sym).with(*args).and_return events
     #described_class.should_receive(:show_audit_events).with(events, an_instance_of(Hash))
   end
 
@@ -49,7 +49,7 @@ describe Conjur::Command::Audit, logged_in: true do
       end
       context "without an account" do
         it_calls_the_api "audit:role bar:baz", :audit_role, 'the-conjur-account:bar:baz', {} do
-          Conjur::Command.stub(conjur_account: "the-conjur-account")
+          allow(Conjur::Command).to receive_messages(conjur_account: "the-conjur-account")
         end
       end
       context "without enough tokens" do
@@ -68,7 +68,7 @@ describe Conjur::Command::Audit, logged_in: true do
       end
       context "an id with two tokens" do
         it_calls_the_api "audit:resource foo:bar", :audit_resource, "the-conjur-account:foo:bar", {} do
-          Conjur::Command.stub(conjur_account: "the-conjur-account")
+          allow(Conjur::Command).to receive_messages(conjur_account: "the-conjur-account")
         end
       end
       context "an id with one token" do
@@ -85,7 +85,7 @@ describe Conjur::Command::Audit, logged_in: true do
     include_context "default audit behavior"
     
     before {
-      api.stub(:audit_event_feed).and_yield([audit_event])
+      allow(api).to receive(:audit_event_feed).and_yield([audit_event])
     }
 
     describe_command "audit all" do
@@ -318,30 +318,30 @@ describe Conjur::Command::Audit, logged_in: true do
   describe "limit and offset" do
     let(:events) { (1 .. 5).map { |x| { event: x } } }
     before {
-      api.stub(:audit_event_feed).and_yield(events)
+      allow(api).to receive(:audit_event_feed).and_yield(events)
     }
 
     describe_command "audit all" do 
       it "prints all the elements" do
-        (expect { invoke }.to write).should ==  events.map {|e| JSON.pretty_generate(e)}.join("\n")+"\n"  
+        expect(expect { invoke }.to write).to eq(events.map {|e| JSON.pretty_generate(e)}.join("\n")+"\n")  
       end
     end
 
     describe_command "audit all -l 2" do  
       it "prints only <limit> elements" do
-        (expect { invoke }.to write).should ==  events[0..1].map {|e| JSON.pretty_generate(e)}.join("\n")+"\n"  
+        expect(expect { invoke }.to write).to eq(events[0..1].map {|e| JSON.pretty_generate(e)}.join("\n")+"\n")  
       end
     end
 
     describe_command "audit all -o 2" do  
       it "skips <offset> elements" do
-        (expect { invoke }.to write).should ==  events[2..4].map {|e| JSON.pretty_generate(e)}.join("\n")+"\n"   
+        expect(expect { invoke }.to write).to eq(events[2..4].map {|e| JSON.pretty_generate(e)}.join("\n")+"\n")   
       end
     end
 
     describe_command "audit all -o 2 -l 2" do
       it "skips <offset> elements and prints only <limit> of remaining part" do
-        (expect { invoke }.to write).should ==  events[2..3].map {|e| JSON.pretty_generate(e)}.join("\n")+"\n"
+        expect(expect { invoke }.to write).to eq(events[2..3].map {|e| JSON.pretty_generate(e)}.join("\n")+"\n")
       end
     end
 

data/spec/command/authn_spec.rb

@@ -1,36 +1,36 @@
 require 'spec_helper'
 
 describe Conjur::Command::Authn do
-  context logged_in: false do
+  context "when not logged in", logged_in: false do
     context "logging in" do
       [ "authn:login", "authn login" ].each do |cmd|
         before do
-          Conjur::Authn.stub(:write_credentials)
+          allow(Conjur::Authn).to receive(:write_credentials)
         end
         describe_command "#{cmd}" do
           it "prompts for username and password and logs in the user" do
-            Conjur::Authn.should_receive(:ask_for_credentials).with({}).and_return [ "the-user", "the-api-key" ]
+            expect(Conjur::Authn).to receive(:ask_for_credentials).with({}).and_return [ "the-user", "the-api-key" ]
   
             expect { invoke }.to write("Logged in")
           end
         end
         describe_command "#{cmd} -u the-user" do
           it "prompts for password and logs in the user" do
-            Conjur::Authn.should_receive(:ask_for_credentials).with({username: 'the-user'}).and_return [ "the-user", "the-api-key" ]
+            expect(Conjur::Authn).to receive(:ask_for_credentials).with({username: 'the-user'}).and_return [ "the-user", "the-api-key" ]
   
             expect { invoke }.to write("Logged in")
           end
         end
         describe_command "#{cmd} -u the-user -p the-password" do
           it "logs in the user" do
-            Conjur::Authn.should_receive(:ask_for_credentials).with({username: 'the-user', password: 'the-password'}).and_return [ "the-user", "the-api-key" ]
+            expect(Conjur::Authn).to receive(:ask_for_credentials).with({username: 'the-user', password: 'the-password'}).and_return [ "the-user", "the-api-key" ]
 
             expect { invoke }.to write("Logged in")
           end
         end
         describe_command "#{cmd} -p the-password the-user" do
           it "logs in the user" do
-            Conjur::Authn.should_receive(:ask_for_credentials).with({username: 'the-user', password: 'the-password'}).and_return [ "the-user", "the-api-key" ]
+            expect(Conjur::Authn).to receive(:ask_for_credentials).with({username: 'the-user', password: 'the-password'}).and_return [ "the-user", "the-api-key" ]
 
             expect { invoke }.to write("Logged in")
           end
@@ -45,11 +45,11 @@ describe Conjur::Command::Authn do
     end
   end
 
-  context logged_in: true do
+  context "when logged in", logged_in: true do
     describe_command 'authn:logout' do
       it "deletes credentials" do
         expect { invoke }.to write("Logged out")
-        netrc[authn_host].should_not be
+        expect(netrc[authn_host]).not_to be
       end
     end
 

data/spec/command/env_spec.rb

@@ -5,34 +5,34 @@ require 'tempfile'
 
 shared_examples_for "processes environment definition" do |cmd, options|
   before {  # suspend all interaction with the environment
-    Kernel.stub(:system).and_return(true) 
+    allow(Kernel).to receive(:system).and_return(true) 
   }
   let(:stub_object) { double(obtain:{}, check:{}) }
 
   describe_command "env:#{cmd} #{options}" do
     it "uses .conjurenv file by default" do
-      Conjur::Env.should_receive(:new).with(file:".conjurenv").and_return(stub_object)
+      expect(Conjur::Env).to receive(:new).with(file:".conjurenv").and_return(stub_object)
       invoke
     end
   end
 
   describe_command "env:#{cmd} -c somefile #{options}" do
     it "uses desired file" do
-      Conjur::Env.should_receive(:new).with(file:"somefile").and_return(stub_object)
+      expect(Conjur::Env).to receive(:new).with(file:"somefile").and_return(stub_object)
       invoke
     end
   end
   
   describe_command "env:#{cmd} --yaml someyaml #{options}" do
     it "uses inline yaml" do
-      Conjur::Env.should_receive(:new).with(yaml:"someyaml").and_return(stub_object)
+      expect(Conjur::Env).to receive(:new).with(yaml:"someyaml").and_return(stub_object)
       invoke
     end
   end
 
   describe_command "env:#{cmd} -c somefile --yaml someyaml #{options}" do
     it "refuses to accept mutually exclusive options" do      
-      Conjur::Env.should_not_receive(:new)
+      expect(Conjur::Env).not_to receive(:new)
       expect { invoke }.to raise_error /Options -c and --yaml can not be provided together/
     end
   end
@@ -45,11 +45,11 @@ describe Conjur::Command::Env, logged_in: true do
     it_behaves_like "processes environment definition", "check", ''
 
     describe_command "env:check" do
-      before { Conjur::Env.should_receive(:new).and_return(stub_env) }
+      before { expect(Conjur::Env).to receive(:new).and_return(stub_env) }
       describe "without api errors" do
         let(:stub_result) {  { "a" => :available, "b"=> :available } }
         before {
-          stub_env.should_receive(:check).with(an_instance_of(Conjur::API)).and_return(stub_result)
+          expect(stub_env).to receive(:check).with(an_instance_of(Conjur::API)).and_return(stub_result)
         }
 
         describe "if all variables are available" do
@@ -73,7 +73,7 @@ describe Conjur::Command::Env, logged_in: true do
         end
       end
       it 'does not rescue unexpected errors' do
-        stub_env.should_receive(:check).with(an_instance_of(Conjur::API)).and_return { raise "Custom error" }
+        expect(stub_env).to receive(:check).with(an_instance_of(Conjur::API)) { raise "Custom error" }
         expect { invoke }.to raise_error "Custom error"
       end
     end
@@ -83,27 +83,27 @@ describe Conjur::Command::Env, logged_in: true do
     it_behaves_like "processes environment definition", "run","-- extcmd"
     describe_command "env:run" do
       it 'fails because of missing argument' do 
-        Kernel.should_not_receive(:system)
+        expect(Kernel).not_to receive(:system)
         expect { invoke }.to raise_error "External command with optional arguments should be provided" 
       end 
     end
     describe_command "env:run -- extcmd --arg1 arg2" do
       before { 
-        Conjur::Env.should_receive(:new).and_return(stub_env)
+        expect(Conjur::Env).to receive(:new).and_return(stub_env)
       }
 
       describe "if no errors are raised" do
         let(:stub_result) { { "a" => "value_a", "b" => "value_b" } }
         before {
-          stub_env.should_receive(:obtain).with(an_instance_of(Conjur::API)).and_return(stub_result)
+          expect(stub_env).to receive(:obtain).with(an_instance_of(Conjur::API)).and_return(stub_result)
         }
         it "performs #exec with environment (names in uppercase)" do
-          Kernel.should_receive(:system).with({"A"=>"value_a", "B"=>"value_b"}, "extcmd", "--arg1","arg2").and_return(true)
+          expect(Kernel).to receive(:system).with({"A"=>"value_a", "B"=>"value_b"}, "extcmd", "--arg1","arg2").and_return(true)
           invoke 
         end
       end
       it "does not rescue unexpected errors" do
-        stub_env.should_receive(:obtain).with(an_instance_of(Conjur::API)).and_return { raise "Custom error" } 
+        expect(stub_env).to receive(:obtain).with(an_instance_of(Conjur::API)) { raise "Custom error" } 
         expect { invoke }.to raise_error "Custom error"
       end
     end
@@ -112,17 +112,17 @@ describe Conjur::Command::Env, logged_in: true do
   describe ":template" do
     context do 
       before { # prevent real operation
-        File.stub(:readable?).with("config.erb").and_return(true)
-        File.stub(:read).with("config.erb").and_return("template")
-        ERB.stub(:new).and_return(double(result:''))
-        Tempfile.stub(:new).and_return(double(write: true, close: true, path: 'somepath'))
-        FileUtils.stub(:copy).and_return(true)
+        allow(File).to receive(:readable?).with("config.erb").and_return(true)
+        allow(File).to receive(:read).with("config.erb").and_return("template")
+        allow(ERB).to receive(:new).and_return(double(result:''))
+        allow(Tempfile).to receive(:new).and_return(double(write: true, close: true, path: 'somepath'))
+        allow(FileUtils).to receive(:copy).and_return(true)
       }
       it_behaves_like "processes environment definition", "template","config.erb"
     end
     describe_command "env:template" do
       it 'fails because of missing argument' do 
-        Tempfile.should_not_receive(:new)
+        expect(Tempfile).not_to receive(:new)
         expect { invoke }.to raise_error "Location of readable ERB template should be provided"
       end 
     end
@@ -133,18 +133,18 @@ other variable <%= conjurenv['b'] %>
 """
       }
       before { 
-        File.stub(:readable?).with("config.erb").and_return(true)
-        File.stub(:read).with("config.erb").and_return(erb_template)
-        Conjur::Env.should_receive(:new).and_return(stub_env)
-        stub_env.should_receive(:obtain).with(an_instance_of(Conjur::API)).and_return( {"a"=>"value_a","b"=>"value_b","c"=>"value_c"} )
+        allow(File).to receive(:readable?).with("config.erb").and_return(true)
+        allow(File).to receive(:read).with("config.erb").and_return(erb_template)
+        expect(Conjur::Env).to receive(:new).and_return(stub_env)
+        expect(stub_env).to receive(:obtain).with(an_instance_of(Conjur::API)).and_return( {"a"=>"value_a","b"=>"value_b","c"=>"value_c"} )
       }
 
       it "creates persistent tempfile, saves rendered template into it, prints out name of the file" do 
         stubpath="/tmp/temp.file"
         tempfile=double(close: true, path: stubpath)
-        Tempfile.should_receive(:new).and_return(tempfile)
-        tempfile.should_receive(:write).with("\nvariable value_a\nother variable value_b\n")  
-        FileUtils.should_receive(:copy).with(stubpath,stubpath+'.saved') # avoid garbage collection
+        expect(Tempfile).to receive(:new).and_return(tempfile)
+        expect(tempfile).to receive(:write).with("\nvariable value_a\nother variable value_b\n")  
+        expect(FileUtils).to receive(:copy).with(stubpath,stubpath+'.saved') # avoid garbage collection
         expect { invoke }.to write stubpath+".saved"
       end
     end

data/spec/command/groups_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Conjur::Command::Groups, logged_in: true do
   describe_command "group:members:add group user:alice" do
     it "adds the role to the group" do
-           RestClient::Request.should_receive(:execute).with(
+           expect(RestClient::Request).to receive(:execute).with(
         method: :put,
         url: "https://authz.example.com/the-account/roles/group/group/?members&member=user:alice",
         headers: {},
@@ -15,7 +15,7 @@ describe Conjur::Command::Groups, logged_in: true do
 
   describe_command "group:members:add -a group user:alice" do
     it "adds the role to the group with admin option" do
-       RestClient::Request.should_receive(:execute).with(
+       expect(RestClient::Request).to receive(:execute).with(
         method: :put,
         url: "https://authz.example.com/the-account/roles/group/group/?members&member=user:alice",
         headers: {},
@@ -26,7 +26,7 @@ describe Conjur::Command::Groups, logged_in: true do
   end
   describe_command "group:members:add -a group alice" do
     it "assumes that a nake member name is a user" do
-           RestClient::Request.should_receive(:execute).with(
+           expect(RestClient::Request).to receive(:execute).with(
         method: :put,
         url: "https://authz.example.com/the-account/roles/group/group/?members&member=user:alice",
         headers: {},
@@ -38,7 +38,7 @@ describe Conjur::Command::Groups, logged_in: true do
 
   describe_command "group:members:add -r group alice" do
     it "revokes the admin rights" do
-       RestClient::Request.should_receive(:execute).with(
+       expect(RestClient::Request).to receive(:execute).with(
         method: :put,
         url: "https://authz.example.com/the-account/roles/group/group/?members&member=user:alice",
         headers: {},

data/spec/command/hosts_spec.rb

@@ -5,7 +5,7 @@ describe Conjur::Command::Hosts, logged_in: true do
   
   describe_command "host:create" do
     it "lets the server assign the id" do
-     RestClient::Request.should_receive(:execute).with(
+     expect(RestClient::Request).to receive(:execute).with(
         method: :post,
         url: collection_url,
         headers: {},
@@ -17,7 +17,7 @@ describe Conjur::Command::Hosts, logged_in: true do
   end
   describe_command "host:create the-id" do
     it "propagates the user-assigned id" do
-     RestClient::Request.should_receive(:execute).with(
+     expect(RestClient::Request).to receive(:execute).with(
         method: :post,
         url: collection_url,
         headers: {},

data/spec/command/init_spec.rb

@@ -49,28 +49,28 @@ describe Conjur::Command::Init do
 
   context logged_in: false do
     before {
-      File.stub(:exists?).and_return false
+      allow(File).to receive(:exists?).and_return false
     }
 
     context "auto-fetching fingerprint" do
       before {
-        HighLine.any_instance.stub(:ask).with("Enter the hostname (and optional port) of your Conjur endpoint: ").and_return "the-host"
-        Conjur::Command::Init.stub get_certificate: ["the-fingerprint", nil]
-        HighLine.any_instance.stub(:ask).with(/^Trust this certificate/).and_return "yes"
+        allow_any_instance_of(HighLine).to receive(:ask).with("Enter the hostname (and optional port) of your Conjur endpoint: ").and_return "the-host"
+        allow(Conjur::Command::Init).to receive_messages get_certificate: ["the-fingerprint", nil]
+        allow_any_instance_of(HighLine).to receive(:ask).with(/^Trust this certificate/).and_return "yes"
       }
 
       describe_command 'init' do
         it "fetches account and writes config file" do
           # Stub hostname
-          Conjur::Core::API.should_receive(:info).and_return "account" => "the-account"
-          File.should_receive(:open)
+          expect(Conjur::Core::API).to receive(:info).and_return "account" => "the-account"
+          expect(File).to receive(:open)
           invoke
         end
       end
 
       describe_command 'init -a the-account' do
         it "writes config file" do
-          File.should_receive(:open)
+          expect(File).to receive(:open)
           invoke
         end
       end
@@ -100,7 +100,7 @@ describe Conjur::Command::Init do
 
     describe_command 'init -a the-account -h localhost -c the-cert' do
       it "writes config and cert files" do
-        File.should_receive(:open).twice
+        expect(File).to receive(:open).twice
         invoke
       end
     end
@@ -137,17 +137,26 @@ describe Conjur::Command::Init do
       context "default behavior" do
         describe_command "init -a the-account -h localhost -c the-cert" do
           before(:each) {
-            File.stub(:expand_path).and_call_original
-            File.stub(:expand_path).with('~/.conjurrc').and_return("#{tmpdir}/.conjurrc")
+            allow(File).to receive(:expand_path).and_call_original
+            allow(File).to receive(:expand_path).with('~/.conjurrc').and_return("#{tmpdir}/.conjurrc")
           }
   
           include_examples "check config and cert files", "#{tmpdir}/.conjurrc"
+          it "prints the config file location" do
+            expect { invoke }.to write("Wrote configuration to #{tmpdir}/.conjurrc")
+          end
+          it "prints the cert location" do
+            expect { invoke }.to write("Wrote certificate to #{tmpdir}/conjur-the-account.pem")
+          end
         end
       end
 
       context "explicit output file" do
         describe_command "init -f #{tmpdir}/.conjurrc2 -a the-account -h localhost -c the-cert" do
           include_examples "check config and cert files", File.join(tmpdir, ".conjurrc2")
+          it "prints the config file location" do
+            expect { invoke }.to write("Wrote configuration to #{tmpdir}/.conjurrc2")
+          end
         end
       end
 

data/spec/command/layers_spec.rb

@@ -6,16 +6,16 @@ describe Conjur::Command::Layers, logged_in: true do
   [ "layer hosts add", "layer:hosts:add" ].each do |cmd|
     describe_command "#{cmd} the-layer the-host" do
       it "adds a host id to the layer" do
-        Conjur::API.any_instance.should_receive(:layer).with("the-layer").and_return layer
-        layer.should_receive(:add_host).with("the-account:host:the-host")
+        expect_any_instance_of(Conjur::API).to receive(:layer).with("the-layer").and_return layer
+        expect(layer).to receive(:add_host).with("the-account:host:the-host")
   
         expect { invoke }.to write("Host added")
       end
     end
     describe_command "#{cmd} the-layer host:the-host" do
       it "adds a qualified host id to the layer" do
-        Conjur::API.any_instance.should_receive(:layer).with("the-layer").and_return layer
-        layer.should_receive(:add_host).with("host:the-host")
+        expect_any_instance_of(Conjur::API).to receive(:layer).with("the-layer").and_return layer
+        expect(layer).to receive(:add_host).with("host:the-host")
   
         expect { invoke }.to write("Host added")
       end
@@ -25,8 +25,8 @@ describe Conjur::Command::Layers, logged_in: true do
   [ "layer hosts remove", "layer:hosts:remove" ].each do |cmd|
     describe_command "#{cmd} the-layer the-host" do
       it "adds a host to the layer" do
-        Conjur::API.any_instance.should_receive(:layer).with("the-layer").and_return layer
-        layer.should_receive(:remove_host).with("the-account:host:the-host")
+        expect_any_instance_of(Conjur::API).to receive(:layer).with("the-layer").and_return layer
+        expect(layer).to receive(:remove_host).with("the-account:host:the-host")
   
         expect { invoke }.to write("Host removed")
       end

data/spec/command/policy_spec.rb

@@ -14,7 +14,7 @@ describe Conjur::Command::Policy do
     end
   end
 
-  context logged_in: true do
+  context "when logged in", logged_in: true do
     let(:role) do
       double("role", exists?: true, api_key: "the-api-key", roleid: "the-role")
     end
@@ -22,31 +22,31 @@ describe Conjur::Command::Policy do
       double("resource", exists?: true).as_null_object
     end
     before {
-      File.stub(:exists?).with("policy.rb").and_return true
-      File.stub(:read).with("policy.rb").and_return "{}"
-      Conjur::DSL::Runner.any_instance.stub(:api).and_return api
+      allow(File).to receive(:exists?).with("policy.rb").and_return true
+      allow(File).to receive(:read).with("policy.rb").and_return "{}"
+      allow_any_instance_of(Conjur::DSL::Runner).to receive(:api).and_return api
     }
     before {
-      api.stub(:role).and_call_original
-      api.stub(:resource).and_call_original
-      api.stub(:role).with("the-account:policy:#{collection}/the-policy-1.0.0").and_return role
-      api.stub(:resource).with("the-account:policy:#{collection}/the-policy-1.0.0").and_return resource
+      allow(api).to receive(:role).and_call_original
+      allow(api).to receive(:resource).and_call_original
+      allow(api).to receive(:role).with("the-account:policy:#{collection}/the-policy-1.0.0").and_return role
+      allow(api).to receive(:resource).with("the-account:policy:#{collection}/the-policy-1.0.0").and_return resource
     }
     
     describe_command 'policy:load --collection the-collection http://example.com/policy.rb' do
       let(:collection) { "the-collection" }
       before {
-        File.stub(:exists?).with("http://example.com/policy.rb").and_return false
-        URI.stub(:parse).with("http://example.com/policy.rb").and_return double(:uri, read: "{}")
+        allow(File).to receive(:exists?).with("http://example.com/policy.rb").and_return false
+        allow(URI).to receive(:parse).with("http://example.com/policy.rb").and_return double(:uri, read: "{}")
       }
       it "creates the policy" do
-        invoke.should == 0
+        expect(invoke).to eq(0)
       end
     end
     describe_command 'policy:load --collection the-collection policy.rb' do
       let(:collection) { "the-collection" }
       it "creates the policy" do
-        invoke.should == 0
+        expect(invoke).to eq(0)
       end
     end
     context "default collection" do
@@ -57,15 +57,15 @@ describe Conjur::Command::Policy do
       describe_command 'policy:load --as-group the-group policy.rb' do
         let(:group) { double(:group, exists?: true) }
         it "creates the policy" do
-          Conjur::Command.api.stub(:role).with("the-account:group:the-group").and_return group
-          Conjur::DSL::Runner.any_instance.should_receive(:owner=).with("the-account:group:the-group")
+          allow(Conjur::Command.api).to receive(:role).with("the-account:group:the-group").and_return group
+          expect_any_instance_of(Conjur::DSL::Runner).to receive(:owner=).with("the-account:group:the-group")
           
-          invoke.should == 0
+          expect(invoke).to eq(0)
         end
       end
       describe_command 'policy:load policy.rb' do
         it "creates the policy with default collection" do
-          invoke.should == 0
+          expect(invoke).to eq(0)
         end
       end
     end