conjur-cli 4.14.0 → 4.15.0

data/spec/dsl/runner_spec.rb

@@ -13,25 +13,25 @@ describe Conjur::DSL::Runner, logged_in: true do
     end
   }
   before {
-    Conjur.stub(:account).and_return "the-account"
-    runner.stub(:api).and_return api
+    allow(Conjur).to receive(:account).and_return "the-account"
+    allow(runner).to receive(:api).and_return api
   }
   it "should populate the root ownerid" do
-    api.should_receive(:user).with("alice").and_return double("alice-exists", exists?: false)
-    api.should_receive(:create_user).with(id: "alice", ownerid: "user:bob").and_return alice
+    expect(api).to receive(:user).with("alice").and_return double("alice-exists", exists?: false)
+    expect(api).to receive(:create_user).with(id: "alice", ownerid: "user:bob").and_return alice
     
     runner.owner = "user:bob"
     runner.execute
   end
   it "should store the api_key in the context keyed by roleid" do
-    api.should_receive(:user).with("alice").and_return double("alice-exists", exists?: false)
-    api.should_receive(:create_user).with(id: "alice").and_return alice
+    expect(api).to receive(:user).with("alice").and_return double("alice-exists", exists?: false)
+    expect(api).to receive(:create_user).with(id: "alice").and_return alice
     
     runner.execute
     
-    runner.context['api_keys'].should == {
+    expect(runner.context['api_keys']).to eq({
       "the-account:user:alice" => "the-api-key"
-    }
+    })
   end
 
   it "doesn't store default env and stack in context" do

data/spec/env_spec.rb

@@ -7,7 +7,7 @@ describe Conjur::Env do
 
     describe "requires either :file or :yaml parameter" do
       before { 
-        Conjur::Env.any_instance.should_not_receive(:parse) 
+        expect_any_instance_of(Conjur::Env).not_to receive(:parse) 
       }
       it "fails if both options are provided" do
         expect { Conjur::Env.new(file: 'f', yaml: 'y') }.to raise_error ":file and :yaml options can not be provided together"
@@ -33,20 +33,20 @@ describe Conjur::Env do
 
       describe "if :file parameter provided" do
         it "does not catch any errors from File.read" do
-          Conjur::Env.any_instance.should_not_receive(:parse) 
-          File.stub(:read).with('unexisting').and_return { raise "Custom error" }
+          expect_any_instance_of(Conjur::Env).not_to receive(:parse) 
+          allow(File).to receive(:read).with('unexisting') { raise "Custom error" }
           expect { Conjur::Env.new(file: 'unexisting') }.to raise_error "Custom error"
         end 
 
         it "if file is readable, passes contents to #parse and stores result in @definition attribute" do 
-          File.should_receive(:read).with("somefile").and_return(:file_contents) 
-          Conjur::Env.any_instance.should_receive(:parse).with(:file_contents).and_return(:stub_parsed) 
-          Conjur::Env.new(file:"somefile").instance_variable_get("@definition").should == :stub_parsed
+          expect(File).to receive(:read).with("somefile").and_return(:file_contents) 
+          expect_any_instance_of(Conjur::Env).to receive(:parse).with(:file_contents).and_return(:stub_parsed) 
+          expect(Conjur::Env.new(file:"somefile").instance_variable_get("@definition")).to eq(:stub_parsed)
         end
       end
       it "if :yaml parameter provided, passes it to #parse and stores result in @definition attribute" do
-        Conjur::Env.any_instance.should_receive(:parse).with("custom yaml").and_return(:stub_parsed)
-        Conjur::Env.new(yaml:"custom yaml").instance_variable_get("@definition").should == :stub_parsed
+        expect_any_instance_of(Conjur::Env).to receive(:parse).with("custom yaml").and_return(:stub_parsed)
+        expect(Conjur::Env.new(yaml:"custom yaml").instance_variable_get("@definition")).to eq(:stub_parsed)
       end
     end
   end
@@ -54,7 +54,7 @@ describe Conjur::Env do
   describe "#parse (called from 'initialize')" do
 
     it 'parses input as YAML and does not hide YAML errors' do
-      YAML.should_receive(:load).with("custom yaml").and_return { raise "Custom error" }
+      expect(YAML).to receive(:load).with("custom yaml") { raise "Custom error" }
       expect { Conjur::Env.new(yaml: "custom yaml") }.to raise_error "Custom error"
     end
 
@@ -75,15 +75,15 @@ describe Conjur::Env do
 
     it "Returns hash consisting of literals, ConjurTempfile and ConjurVariable objects" do
       result = Conjur::Env.new(yaml: "{a: literal, b: !tmp 'sometmp', c: !var 'somevar'}").instance_variable_get("@definition")
-      result.keys.sort.should == ["a","b","c"]
-      result["a"].should == 'literal'
-      result["b"].should be_a_kind_of(Conjur::Env::ConjurTempfile)
-      result["c"].should be_a_kind_of(Conjur::Env::ConjurVariable)
+      expect(result.keys.sort).to eq(["a","b","c"])
+      expect(result["a"]).to eq('literal')
+      expect(result["b"]).to be_a_kind_of(Conjur::Env::ConjurTempfile)
+      expect(result["c"]).to be_a_kind_of(Conjur::Env::ConjurVariable)
     end
 
     it "Converts numbers to string literals" do
       result = Conjur::Env.new(yaml: "{a: 123}").instance_variable_get("@definition")
-      result["a"].should == "123"
+      expect(result["a"]).to eq("123")
     end
 
   end
@@ -91,34 +91,34 @@ describe Conjur::Env do
   describe "#obtain", logged_in: true do
     let(:subject) { Conjur::Env.new(yaml: "{a: literal, b: !tmp tempfile, c: !var conjurvar}") }
     before { 
-      api.stub(:variable_values).with(["tempfile","conjurvar"]).and_return({"tempfile" => "stubtemp", "conjurvar" => "stubvar" })
+      allow(api).to receive(:variable_values).with(["tempfile","conjurvar"]).and_return({"tempfile" => "stubtemp", "conjurvar" => "stubvar" })
     }
 
     it "requests variable_values with list of !var and !tmp values" do    
-      Conjur::Env::ConjurTempfile.any_instance.stub(:evaluate).and_return(:stub_value) # avoid tempfiles creation
-      api.should_receive(:variable_values).with(["tempfile","conjurvar"]).and_return({"tempfile" => "stub1", "conjurvar" => "stub2" })
+      allow_any_instance_of(Conjur::Env::ConjurTempfile).to receive(:evaluate).and_return(:stub_value) # avoid tempfiles creation
+      expect(api).to receive(:variable_values).with(["tempfile","conjurvar"]).and_return({"tempfile" => "stub1", "conjurvar" => "stub2" })
       subject.obtain(api)
     end
 
     it 'does not suppress api errors' do  
-      api.stub(:variable_values).and_return { raise "Custom API error" }
+      allow(api).to receive(:variable_values) { raise "Custom API error" }
       expect { subject.obtain(api) }.to raise_error "Custom API error" 
     end
 
     describe "for !tmp creates temporary files with Conjur variable value" do
       it "in /dev/shm if it exists" do  
         tempfile = double(path: '/dev/shm/newfile', close: true)
-        File.should_receive(:directory?).with("/dev/shm").and_return(true)
-        File.should_receive(:writable?).with("/dev/shm").and_return(true)
-        Tempfile.should_receive(:new).with("conjur","/dev/shm").and_return(tempfile)
-        tempfile.should_receive(:write).with("stubtemp")
+        expect(File).to receive(:directory?).with("/dev/shm").and_return(true)
+        expect(File).to receive(:writable?).with("/dev/shm").and_return(true)
+        expect(Tempfile).to receive(:new).with("conjur","/dev/shm").and_return(tempfile)
+        expect(tempfile).to receive(:write).with("stubtemp")
         subject.obtain(api)
       end
       it "otherwise uses Tempfile defaults" do
         tempfile = double(path: '/tmp/newfile', close: true)
-        File.should_receive(:directory?).with("/dev/shm").and_return(false)
-        Tempfile.should_receive(:new).with("conjur").and_return(tempfile)
-        tempfile.should_receive(:write).with("stubtemp")
+        expect(File).to receive(:directory?).with("/dev/shm").and_return(false)
+        expect(Tempfile).to receive(:new).with("conjur").and_return(tempfile)
+        expect(tempfile).to receive(:write).with("stubtemp")
         subject.obtain(api)
       end
     end
@@ -126,20 +126,20 @@ describe Conjur::Env do
     describe "returns hash consisting of original keys and following values" do
       before {  
         tempfile=double(path:"/stub/tempfile",write: true, close: true)
-        File.stub(:directory?).with("/dev/shm").and_return(true)
-        File.stub(:writable?).with("/dev/shm").and_return(true)
-        Tempfile.stub(:new).with("conjur","/dev/shm").and_return(tempfile)
+        allow(File).to receive(:directory?).with("/dev/shm").and_return(true)
+        allow(File).to receive(:writable?).with("/dev/shm").and_return(true)
+        allow(Tempfile).to receive(:new).with("conjur","/dev/shm").and_return(tempfile)
       }
       let(:result) { subject.obtain(api) }
 
       it 'literals' do
-        result.should include("a"=>"literal") 
+        expect(result).to include("a"=>"literal") 
       end
       it '!tmp: names of temp files' do
-        result.should include("b"=>"/stub/tempfile")
+        expect(result).to include("b"=>"/stub/tempfile")
       end
       it '!var: variable values' do
-        result.should include("c"=>"stubvar")
+        expect(result).to include("c"=>"stubvar")
       end
     end
   end
@@ -148,38 +148,38 @@ describe Conjur::Env do
 
     let(:subject) { Conjur::Env.new(yaml: "{a: literal, b: !tmp tempfile_b, c: !var conjurvar_c, d: !tmp tempfile_d, e: !var conjurvar_e }") }
     before { 
-      api.should_not_receive(:variable_values) 
-      Tempfile.should_not_receive(:new)
+      expect(api).not_to receive(:variable_values) 
+      expect(Tempfile).not_to receive(:new)
     }
     let(:permitted)  { double(permitted?:true) }
     let(:restricted) { double(permitted?:false) }
 
     it "requests resource 'execute' permission for each !var and !tmp value" do
-      api.should_receive(:resource).with("variable:tempfile_b").and_return(permitted) 
-      api.should_receive(:resource).with("variable:conjurvar_c").and_return(permitted) 
-      api.should_receive(:resource).with("variable:tempfile_d").and_return(permitted) 
-      api.should_receive(:resource).with("variable:conjurvar_e").and_return(permitted) 
-      permitted.should_receive(:permitted?).exactly(4).times.with(:execute).and_return(true)
+      expect(api).to receive(:resource).with("variable:tempfile_b").and_return(permitted) 
+      expect(api).to receive(:resource).with("variable:conjurvar_c").and_return(permitted) 
+      expect(api).to receive(:resource).with("variable:tempfile_d").and_return(permitted) 
+      expect(api).to receive(:resource).with("variable:conjurvar_e").and_return(permitted) 
+      expect(permitted).to receive(:permitted?).exactly(4).times.with(:execute).and_return(true)
       subject.check(api)
     end
 
     it 'does not rescue from unexpected api errors' do  
-      api.should_receive(:resource).with("variable:tempfile_b").and_return { raise "Custom error" }
+      expect(api).to receive(:resource).with("variable:tempfile_b") { raise "Custom error" }
       expect { subject.check(api) }.to raise_error "Custom error"
     end
 
     it "returns Hash consisting of original keys and following statuses: :literal, :available, :unavailable" do
-      api.should_receive(:resource).with("variable:tempfile_b").and_return(permitted) 
-      api.should_receive(:resource).with("variable:conjurvar_c").and_return(restricted) 
-      api.should_receive(:resource).with("variable:tempfile_d").and_return(restricted) 
-      api.should_receive(:resource).with("variable:conjurvar_e").and_return(permitted) 
+      expect(api).to receive(:resource).with("variable:tempfile_b").and_return(permitted) 
+      expect(api).to receive(:resource).with("variable:conjurvar_c").and_return(restricted) 
+      expect(api).to receive(:resource).with("variable:tempfile_d").and_return(restricted) 
+      expect(api).to receive(:resource).with("variable:conjurvar_e").and_return(permitted) 
       
-      result = subject.check(api).should == { "a" => :literal, 
+      result = expect(subject.check(api)).to eq({ "a" => :literal, 
                                               "b" => :available, 
                                               "c" => :unavailable, 
                                               "d" => :unavailable, 
                                               "e" => :available 
-                                            }
+                                            })
     end
   end
     

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: conjur-cli
 version: !ruby/object:Gem::Version
-  version: 4.14.0
+  version: 4.15.0
 platform: ruby
 authors:
 - Rafał Rzepecki
@@ -9,182 +9,190 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-05 00:00:00.000000000 Z
+date: 2014-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: conjur-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.10.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 4.10.0
 - !ruby/object:Gem::Dependency
   name: gli
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 2.8.0
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: netrc
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: methadone
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: deep_merge
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: cas_rest_client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2.14'
-    - - <
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '2.14'
-    - - <
+    - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: aruba
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: ci_reporter
+  name: ci_reporter_rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ci_reporter_cucumber
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -199,6 +207,20 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: io-grab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 description: 
 email:
 - divided.mind@gmail.com
@@ -215,6 +237,7 @@ files:
 - .gitignore
 - .kateproject
 - .project
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
@@ -302,17 +325,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: Conjur command line interface