MuranoCLI 3.2.0.beta.9 → 3.2.1.pre.beta.3

data/spec/cmd_keystore_spec.rb

@@ -17,43 +17,41 @@ RSpec.describe 'murano keystore', :cmd, :needs_password do
     murano_solutions_expunge_yes
 
     @product_name = rname('keystoreTest')
-    out, err, status = Open3.capture3(capcmd('murano', 'application', 'create', @product_name, '--save'))
+    out, err = murano_command_run(
+      'solution create', '--type', 'application', @product_name, '--save',
+    )
     expect(err).to eq('')
     expect(out.chomp).to match(/^[a-zA-Z0-9]+$/)
-    expect(status.exitstatus).to eq(0)
 
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'set', 'bob', 'built'))
+    out, err = murano_command_run(
+      'keystore set', 'bob', 'built',
+    )
     expect(out.chomp).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   after(:example) do
-    out, err, status = Open3.capture3(capcmd('murano', 'solution', 'delete', @product_name, '-y'))
+    out, err = murano_command_run('solution delete', @product_name, '-y')
     expect(out).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'gets' do
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'get', 'bob'))
+    out, err = murano_command_run('keystore get', 'bob')
     expect(out.chomp).to eq('built')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'lists' do
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'list'))
+    out, err = murano_command_run('keystore list')
     expect(out.chomp).to eq('bob')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'infos' do
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'info', '-c', 'outformat=json'))
+    out, err = murano_command_run('keystore info', '-c', 'outformat=json')
     expect { out = JSON.parse(out) }.to_not raise_error
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
     expect(out).to match(
       'quota' => { 'keys' => a_kind_of(Integer) },
       'usage' => { 'keys' => 1, 'size' => a_kind_of(Integer) },
@@ -61,44 +59,37 @@ RSpec.describe 'murano keystore', :cmd, :needs_password do
   end
 
   it 'deletes', :club_10s do
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'delete', 'bob'))
+    out, err = murano_command_run('keystore delete', 'bob')
     expect(out.chomp).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
 
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'list'))
+    out, err = murano_command_run('keystore list')
     expect(out.chomp).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'clearAll', :club_10s do
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'set', 'another', 'value'))
+    out, err = murano_command_run('keystore set', 'another', 'value')
     expect(out.chomp).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
 
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'clearAll'))
+    out, err = murano_command_run('keystore clearAll')
     expect(out.chomp).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
 
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'list'))
+    out, err = murano_command_run('keystore list')
     expect(out.chomp).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'can call other commands', :club_10s do
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'command', 'lpush', 'another', 'value'))
+    out, err = murano_command_run('keystore command', 'lpush', 'another', 'value')
     expect(out.chomp).to eq('1')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
 
-    out, err, status = Open3.capture3(capcmd('murano', 'keystore', 'command', 'rpop', 'another'))
+    out, err = murano_command_run('keystore command', 'rpop', 'another')
     expect(out.chomp).to eq('value')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 end
 

data/spec/cmd_link_spec.rb

@@ -38,12 +38,9 @@ RSpec.describe 'murano link', :cmd, :needs_password do
         it 'will not list' do
           # Because we run from the context of the rspec command, the :env
           # config file will have loaded, so business.id will not be set.
-          stdout, stderr = murano_command_run('link list')
-          expect(stdout).to eq(
-            %(Please change to a project directory, or run `murano init` to create a new project.\n)
-          )
+          _stdout, stderr = murano_command_exits('link list')
           expect(stderr).to eq(
-            %(The "link list" command only works in a Murano project.\n)
+            %(No applications found\nNo service links found\n)
           )
         end
       end
@@ -51,33 +48,34 @@ RSpec.describe 'murano link', :cmd, :needs_password do
   end
 
   context 'with project' do
-    before(:example) { project_up(skip_link: true) }
-    after(:example) { project_down }
+    before(:example) do
+      project_up(skip_link: true)
+    end
+
+    after(:example) do
+      project_down
+    end
 
     it 'links and lists', :club_20s, :club_10s do
-      out, err, status = Open3.capture3(capcmd('murano', 'assign', 'set'))
+      out, err = murano_command_run('assign set')
       olines = out.lines
-
       expect(strip_fancy(olines[0])).to eq(
         "Linked '#{@proj_name_prod}' to '#{@proj_name_appy}'\n"
       )
-
       expect(olines[1]).to eq("Created default event handler\n")
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
 
-      out, err, status = Open3.capture3(capcmd('murano', 'assign', 'list'))
+      out, err = murano_command_run('assign list')
       expect(err).to eq('')
       olines = out.lines
       expect(olines[0]).to match(/^(\+-+){3}\+$/)
       expect(olines[1]).to match(/^\| name\s+\| script_key\s+\| service\s+\|$/)
       expect(olines[2]).to match(/^(\+-+){3}\+$/)
       expect(olines[-1]).to match(/^(\+-+){3}\+$/)
-      expect(status.exitstatus).to eq(0)
     end
 
     it 'unlinks', :club_20s, :club_10s do
-      out, err, status = Open3.capture3(capcmd('murano', 'assign', 'set'))
+      out, err = murano_command_run('assign set')
       #expect(out).to a_string_starting_with("Linked product #{@solz_name}")
       olines = out.lines
       expect(strip_fancy(olines[0])).to eq(
@@ -85,9 +83,8 @@ RSpec.describe 'murano link', :cmd, :needs_password do
       )
       expect(olines[1]).to eq("Created default event handler\n")
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
 
-      out, err, status = Open3.capture3(capcmd('murano', 'link', 'unset'))
+      out, err = murano_command_run('link unset')
       #expect(out).to a_string_starting_with("Unlinked #{@solz_name}")
       # E.g.,
       #   Unlinked ‘linktest3e7def1b86a1d680’ from ‘linktest3e7def1b86a1d680’\n
@@ -102,7 +99,6 @@ RSpec.describe 'murano link', :cmd, :needs_password do
         /^Removed '[_a-z0-9]*' from '#{@proj_name_appy}'\n$/
       )
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
     end
   end
 end

data/spec/cmd_password_spec.rb

@@ -13,22 +13,22 @@ RSpec.describe 'murano password', :cmd do
   include_context 'CI_CMD'
 
   it 'Lists when no file' do
-    out, err, status = Open3.capture3(capcmd('murano', 'password', 'list'))
+    out, err = murano_command_run('password list')
     expect(err).to eq('')
     olines = out.lines
     expect(olines[0]).to match(/^(\+-+){2}\+$/)
     expect(olines[1]).to match(/^\| Host\s+\| Username\s+\|$/)
     expect(olines[2]).to match(/^(\+-+){2}\+$/)
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'sets a password' do
-    out, err, status = Open3.capture3(capcmd('murano', 'password', 'set', 'bob@bob.bob', 'an.API.host.i', '--password', 'bad'))
+    out, err = murano_command_run(
+      'password set', 'bob@bob.bob', 'an.API.host.i', '--password', 'bad',
+    )
     expect(err).to eq('')
     expect(out).to eq('')
-    expect(status.exitstatus).to eq(0)
 
-    out, err, status = Open3.capture3(capcmd('murano', 'password', 'list'))
+    out, err = murano_command_run('password list')
     expect(err).to eq('')
     olines = out.lines
     expect(olines[0]).to match(/^(\+-+){2}\+$/)
@@ -36,7 +36,6 @@ RSpec.describe 'murano password', :cmd do
     expect(olines[2]).to match(/^(\+-+){2}\+$/)
     expect(olines[3]).to match(/^\| an.API.host.i\s+\| bob@bob\.bob\s+\|$/)
     expect(olines[4]).to match(/^(\+-+){2}\+$/)
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'deletes a password' do
@@ -46,12 +45,13 @@ RSpec.describe 'murano password', :cmd do
       io << "  bob@bob.bob: badpassword\n"
       io << "  rich@er.u: notbetter\n"
     end
-    out, err, status = Open3.capture3(capcmd('murano', 'password', 'delete', 'rich@er.u', 'an.API.host.i', '-y'))
+    out, err = murano_command_run(
+      'password delete', 'rich@er.u', 'an.API.host.i', '-y',
+    )
     expect(err).to eq('')
     expect(out).to eq('')
-    expect(status.exitstatus).to eq(0)
 
-    out, err, status = Open3.capture3(capcmd('murano', 'password', 'list'))
+    out, err = murano_command_run('password list')
     expect(err).to eq('')
     olines = out.lines
     expect(olines[0]).to match(/^(\+-+){2}\+$/)
@@ -59,7 +59,6 @@ RSpec.describe 'murano password', :cmd do
     expect(olines[2]).to match(/^(\+-+){2}\+$/)
     expect(olines[3]).to match(/^\| an.API.host.i\s+\| bob@bob\.bob\s+\|$/)
     expect(olines[4]).to match(/^(\+-+){2}\+$/)
-    expect(status.exitstatus).to eq(0)
   end
 end
 

data/spec/cmd_setting_application_spec.rb

@@ -18,40 +18,43 @@ RSpec.describe 'murano application setting', :cmd, :needs_password do
     murano_solutions_expunge_yes
 
     @product_name = rname('settingtest')
-    out, err, status = Open3.capture3(capcmd('murano', 'application', 'create', @product_name, '--save'))
+    out, err = murano_command_run(
+      'solution create', '--type', 'application', @product_name, '--save',
+    )
     expect(err).to eq('')
     expect(out.chomp).to match(/^[a-zA-Z0-9]+$/)
-    expect(status.exitstatus).to eq(0)
   end
 
   after(:example) do
-    out, err, status = Open3.capture3(capcmd('murano', 'solution', 'delete', @product_name, '-y'))
+    out, err = murano_command_run('solution delete', @product_name, '-y')
     expect(out).to eq('')
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'reads Webservice.cors' do
-    out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+    out, err = murano_command_run(
+      'setting read', 'Webservice.cors', '-c', 'outformat=json',
+    )
     expect { JSON.parse(out) }.to_not raise_error
     expect(err).to eq('')
-    expect(status.exitstatus).to eq(0)
   end
 
   it 'reads Webservice.cors to a file' do
-    out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-o', 'testout', '-c', 'outformat=json'))
+    out, err = murano_command_run(
+      'setting read', 'Webservice.cors', '-o', 'testout', '-c', 'outformat=json',
+    )
     expect(err).to eq('')
     expect(out).to eq('')
-    expect(status.exitstatus).to eq(0)
     expect(File.exist?('testout')).to be true
   end
 
   context 'Writes (using Webservice.cors)' do
     before(:example) do
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+      out, err = murano_command_run(
+        'setting read', 'Webservice.cors', '-c', 'outformat=json',
+      )
       expect { @json_before = JSON.parse(out) }.to_not raise_error
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
     end
     # {'origin'=>true,
     # 'methods'=>['HEAD', 'GET', 'POST', 'PUT', 'DELETE', 'OPTIONS', 'PATCH'],
@@ -60,172 +63,191 @@ RSpec.describe 'murano application setting', :cmd, :needs_password do
 
     context 'a bool value' do
       it 'Yes', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', 'Yes'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', 'Yes',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = true
         expect(json_after).to match(@json_before)
       end
 
       it 'true', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', 'true'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', 'true',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = true
         expect(json_after).to match(@json_before)
       end
 
       it 'on', :club_30s, :club_20s, :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', 'on'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', 'on',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = true
         expect(json_after).to match(@json_before)
       end
 
       it '1', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', '1'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', '1',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = true
         expect(json_after).to match(@json_before)
       end
 
       it 'bob', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', 'bob'))
-        expect(err).to eq("\e[31mValue \"bob\" is not a bool type!\e[0m\n")
+        out, err = murano_command_exits(
+          'setting write', 'Webservice.cors', 'origin', '--bool', 'bob',
+        )
+        expect(err).to eq("Value \"bob\" is not a bool type!\n")
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(2)
       end
 
       it 'No', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', 'No'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', 'No',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = false
         expect(json_after).to match(@json_before)
       end
 
       it 'false', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', 'false'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', 'false',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = false
         expect(json_after).to match(@json_before)
       end
 
       it 'off', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', 'Off'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', 'Off',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = false
         expect(json_after).to match(@json_before)
       end
 
       it '0', :club_30s, :club_20s, :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool', '0'))
+        out, err = murano_command_run(
+          'setting write', 'Webservice.cors', 'origin', '--bool', '0',
+        )
         expect(err).to eq('')
         expect(out).to eq('')
-        expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = false
         expect(json_after).to match(@json_before)
       end
 
       it 'on STDIN', :club_10s do
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool'), stdin_data: 'true')
+        # FIXME: (lb): Replace capcmd with murano_command_run (need to handle stdin_data).
+        out, err, status = Open3.capture3(capcmd(
+          'murano', 'setting', 'write', 'Webservice.cors', 'origin', '--bool'
+        ), stdin_data: 'true')
         expect(err).to eq('')
         expect(out).to eq('')
         expect(status.exitstatus).to eq(0)
 
-        out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+        out, err = murano_command_run(
+          'setting read', 'Webservice.cors', '-c', 'outformat=json',
+        )
         json_after = nil
         expect { json_after = JSON.parse(out) }.to_not raise_error
         expect(err).to eq('')
-        expect(status.exitstatus).to eq(0)
         @json_before['origin'] = true
         expect(json_after).to match(@json_before)
       end
     end
 
     it 'a json array blob', :club_10s do
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'headers', '--json', '["fidget", "forgotten", "tokens"]'))
+      out, err = murano_command_run(
+        'setting write', 'Webservice.cors', 'headers', '--json', '--', '["fidget", "forgotten", "tokens"]',
+      )
       expect(err).to eq('')
       expect(out).to eq('')
-      expect(status.exitstatus).to eq(0)
 
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+      out, err = murano_command_run(
+        'setting read', 'Webservice.cors', '-c', 'outformat=json',
+      )
       json_after = nil
       expect { json_after = JSON.parse(out) }.to_not raise_error
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
       @json_before['headers'] = %w[fidget forgotten tokens]
       expect(json_after).to match(@json_before)
     end
 
     it 'a json array blob with STDIN', :club_10s do
+      # FIXME: (lb): Replace capcmd with murano_command_run (need to handle stdin_data).
       out, err, status = Open3.capture3(
         capcmd(
-          'murano',
-          'setting',
-          'write',
-          'Webservice.cors',
-          'headers',
-          '--json'
+          'murano', 'setting', 'write', 'Webservice.cors', 'headers', '--json',
         ),
         stdin_data: '["fidget", "forgotten", "tokens"]'
       )
@@ -233,41 +255,46 @@ RSpec.describe 'murano application setting', :cmd, :needs_password do
       expect(out).to eq('')
       expect(status.exitstatus).to eq(0)
 
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+      out, err = murano_command_run(
+        'setting read', 'Webservice.cors', '-c', 'outformat=json',
+      )
       json_after = nil
       expect { json_after = JSON.parse(out) }.to_not raise_error
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
       @json_before['headers'] = %w[fidget forgotten tokens]
       expect(json_after).to match(@json_before)
     end
 
     it 'an array', :club_10s do
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'headers', '--array', 'fidget', 'forgotten', 'tokens'))
+      out, err = murano_command_run(
+        'setting write', 'Webservice.cors', 'headers', '--array', 'fidget', 'forgotten', 'tokens',
+      )
       expect(err).to eq('')
       expect(out).to eq('')
-      expect(status.exitstatus).to eq(0)
 
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+      out, err = murano_command_run(
+        'setting read', 'Webservice.cors', '-c', 'outformat=json',
+      )
       json_after = nil
       expect { json_after = JSON.parse(out) }.to_not raise_error
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
       @json_before['headers'] = %w[fidget forgotten tokens]
       expect(json_after).to match(@json_before)
     end
 
     it 'appends an array', :club_10s do
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'write', 'Webservice.cors', 'headers', '--array', '--append', 'fidget', 'forgotten', 'tokens'))
+      out, err = murano_command_run(
+        'setting write', 'Webservice.cors', 'headers', '--array', '--append', 'fidget', 'forgotten', 'tokens',
+      )
       expect(err).to eq('')
       expect(out).to eq('')
-      expect(status.exitstatus).to eq(0)
 
-      out, err, status = Open3.capture3(capcmd('murano', 'setting', 'read', 'Webservice.cors', '-c', 'outformat=json'))
+      out, err = murano_command_run(
+        'setting read', 'Webservice.cors', '-c', 'outformat=json',
+      )
       json_after = nil
       expect { json_after = JSON.parse(out) }.to_not raise_error
       expect(err).to eq('')
-      expect(status.exitstatus).to eq(0)
       @json_before['headers'] = @json_before['headers'] + %w[fidget forgotten tokens]
       expect(json_after).to match(@json_before)
     end