rainforest-cli 1.10.2 → 1.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0e31fc0fb7e685c2de8fd444e7d5f2a074d19875
-  data.tar.gz: ad40b1b738892368b8597e779a23c25f621dc5a3
+  metadata.gz: 404d70dc620de15e7e6eeb220d60a1809f722ee1
+  data.tar.gz: 9a23f6f532cb6cf9eaf6139868a876d020453392
 SHA512:
-  metadata.gz: 9ea8b9dc6ad22b570efae9b6f379631130062653a92f982b02660fe9dfc8b60f61a2f7678732a0837faf4fb94f613e5c5bd5d8fdfc03e8ecc250fd299ec46c1f
-  data.tar.gz: 644af9ed6b8064c8cfcfd17fe7aaeed20d992d073d968bcb73e66e13533c665c3010bcfea52957444a03dde6488622d9691e74fcf6660b229e881463ba217afc
+  metadata.gz: 34ce70554f9807d0e2db16dd7c6eb58f5a219da7198b3c4db64dfa97ebd745585303ceac5c6f4bf501e45c2eb1bc0274fc023d73bd0642f35216ca65f5c3e38b
+  data.tar.gz: 10b6f5678629a9b9516ca2e6837e04569ffb79b61a35c97e2602073fff16f4f83372fb37debb9b3b82b30182846041ff88d27c1e2b184f7409409bc4424aee68

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Rainforest CLI Changelog
 
+## 1.10.3 - 21st October 2016
+- Fix bug with accidental removal of 3 commands. (d9ebbd702ba1b1b64b9a1a222c301315b89d743e, @curtis-rainforestqa)
+- Add better tolerance for server errors. (b4180332ca13fec0972c3d65dbce00242907ca38, @epaulet)
+
 ## 1.10.2 - 11th October 2016
 - Limit CSV batch upload size to chunks of 20 at a time for more reliability.
 (abfed07df5635eb88029ee0b6cf8eea3a538fff6, @epaulet)

data/lib/rainforest_cli.rb

@@ -33,6 +33,9 @@ module RainforestCli
       c.add('export', 'Export your remote Rainforest tests to RFML') { Exporter.new(options).export }
       c.add('csv-upload', 'Upload a new tabular variable from a CSV file') { CSVImporter.new(options).import }
       c.add('report', 'Create a JUnit report from your run results') { Reporter.new(options).report }
+      c.add('sites', 'Lists the available sites') { Resources.new(options).sites }
+      c.add('folders', 'Lists the available folders') { Resources.new(options).folders }
+      c.add('browsers', 'Lists the available browsers') { Resources.new(options).browsers }
     end
 
     @http_client = HttpClient.new(token: options.token)

data/lib/rainforest_cli/commands.rb

@@ -6,6 +6,8 @@ module RainforestCli
 
     attr_reader :commands
 
+    SUPPORTED_COMMANDS = %w(run new validate upload rm export csv-upload report sites folders browsers)
+
     def initialize
       @commands = []
       yield(self) if block_given?

data/lib/rainforest_cli/csv_importer.rb

@@ -40,8 +40,12 @@ module RainforestCli
         end
       end
 
-      print 'Creating new tabular variable'
-      response = http_client.post '/generators', { name: @generator_name, description: @generator_name, columns: columns }
+      puts 'Creating new tabular variable'
+      response = http_client.post(
+        '/generators',
+        { name: @generator_name, description: @generator_name, columns: columns },
+        { retries_on_failures: true },
+      )
       raise "Error creating tabular variable: #{response['error']}" if response['error']
       puts "\t[OK]"
 
@@ -57,7 +61,8 @@ module RainforestCli
         response = http_client.post(
           "/generators/#{generator_id}/rows/batch",
           { data: data_slice },
-          retries_on_failures: true)
+          { retries_on_failures: true },
+        )
         # NOTE: Response for this endpoint will usually be an array representing all the rows created
         raise response['error'] if response.is_a?(Hash) && response['error']
         p.increment

data/lib/rainforest_cli/deleter.rb

@@ -14,6 +14,7 @@ class RainforestCli::Deleter
     validate_file_extension
     delete_remote_test(test_file)
     delete_local_file(test_file.file_name)
+    logger.info 'Test successfully deleted.'
   end
 
   private

data/lib/rainforest_cli/http_client.rb

@@ -13,81 +13,58 @@ module RainforestCli
       @token = options.fetch(:token)
     end
 
-    def delete(url, body = {})
-      response = HTTParty.delete make_url(url), {
-        body: body,
-        headers: headers,
-        verify: false,
-      }
-
-      JSON.parse(response.body)
+    def delete(path, body = {}, options = {})
+      request(:delete, path, body, options)
     end
 
-    def post(url, body = {}, options = {})
-      wrap_exceptions(options[:retries_on_failures]) do
-        response = HTTParty.post make_url(url), {
-          body: body,
-          headers: headers,
-          verify: false,
-        }
-
-        return JSON.parse(response.body)
-      end
+    def post(path, body = {}, options = {})
+      request(:post, path, body, options)
     end
 
-    def get(url, body = {}, options = {})
-      wrap_exceptions(options[:retries_on_failures]) do
-        response = HTTParty.get make_url(url), {
-          body: body,
-          headers: headers,
-          verify: false,
-        }
-
-        if response.code == 200
-          return JSON.parse(response.body)
-        else
-          RainforestCli.logger.warn("Status Code: #{response.code}, #{response.body}")
-          return nil
-        end
-      end
+    def get(path, body = {}, options = {})
+      request(:get, path, body, options)
     end
 
-    def api_token_set?
-      !@token.nil?
-    end
-
-    private
+    def request(method, path, body, options)
+      url = File.join(API_URL, path)
 
-    def wrap_exceptions(retries_on_failures)
-      @retry_delay = 0
-      @waiting_on_retries = false
       loop do
         begin
-          # Suspend tries until wait period is over
-          if @waiting_on_retries
-            Kernel.sleep 5
+          response = Http::Exceptions.wrap_exception do
+            HTTParty.send(method, url, { body: body, headers: headers, verify: false })
+          end
+
+          if response.code.between?(200, 299)
+            return JSON.parse(response.body)
+          elsif options[:retries_on_failures] && response.code >= 500
+            delay = retry_delay
+            logger.warn "HTTP request was unsuccessful. URL: #{url}. Status: #{response.code}"
+            logger.warn "Retrying again in #{delay} seconds..."
+            Kernel.sleep delay
           else
-            Http::Exceptions.wrap_exception { yield }
-            break
+            logger.fatal "Non 200 code received for request to #{url}"
+            logger.fatal "Server response: #{response.body}"
+            exit 1
           end
         rescue Http::Exceptions::HttpException, Timeout::Error => e
-          raise e unless retries_on_failures
+          raise e unless options[:retries_on_failures]
 
-          unless @waiting_on_retries
-            @waiting_on_retries = true
-            @retry_delay += RETRY_INTERVAL
+          delay = retry_delay
+          logger.warn 'Exception Encountered while trying to contact Rainforest API:'
+          logger.warn "\t\t#{e.message}"
+          logger.warn "Retrying again in #{delay} seconds..."
 
-            RainforestCli.logger.warn 'Exception Encountered while trying to contact Rainforest API:'
-            RainforestCli.logger.warn "\t\t#{e.message}"
-            RainforestCli.logger.warn "Retrying again in #{@retry_delay} seconds..."
-
-            Kernel.sleep @retry_delay
-            @waiting_on_retries = false
-          end
+          Kernel.sleep delay
         end
       end
     end
 
+    def api_token_set?
+      !@token.nil?
+    end
+
+    private
+
     def make_url(url)
       File.join(API_URL, url)
     end
@@ -98,5 +75,14 @@ module RainforestCli
         'User-Agent' => "Rainforest-cli-#{RainforestCli::VERSION}",
       }
     end
+
+    def retry_delay
+      # make retry delay random to desynchronize multiple threads
+      RETRY_INTERVAL + rand(RETRY_INTERVAL)
+    end
+
+    def logger
+      RainforestCli.logger
+    end
   end
 end

data/lib/rainforest_cli/reporter.rb

@@ -22,11 +22,6 @@ module RainforestCli
 
       run = client.get("/runs/#{@run_id}.json")
 
-      if run == nil
-        logger.fatal "Non 200 code recieved"
-        exit 1
-      end
-
       if run['error']
         logger.fatal "Error retrieving results for your run: #{run['error']}"
         exit 1
@@ -35,11 +30,6 @@ module RainforestCli
       if run.has_key?('total_tests') and run['total_tests'] != 0
         tests = client.get("/runs/#{@run_id}/tests.json?page_size=#{run['total_tests']}")
 
-        if tests == nil
-          logger.fatal "Non 200 code recieved"
-          exit 1
-        end
-
         if tests.kind_of?(Hash) and tests['error'] # if this had worked tests would be an array
           logger.fatal "Error retrieving test details for your run: #{tests['error']}"
           exit 1

data/lib/rainforest_cli/runner.rb

@@ -54,16 +54,14 @@ module RainforestCli
       running = true
       while running
         response = client.get("/runs/#{run_id}", {}, retries_on_failures: true)
-        if response
-          state_details = response.fetch('state_details')
-          unless state_details.fetch('is_final_state')
-            state, current_progress = response.values_at('state', 'current_progress')
-            logger.info "Run #{run_id} is #{state} and is #{current_progress['percent']}% complete"
-            running = false if response['result'] == 'failed' && options.failfast?
-          else
-            logger.info "Run #{run_id} is now #{response["state"]} and has #{response["result"]}"
-            running = false
-          end
+        state_details = response.fetch('state_details')
+        unless state_details.fetch('is_final_state')
+          state, current_progress = response.values_at('state', 'current_progress')
+          logger.info "Run #{run_id} is #{state} and is #{current_progress['percent']}% complete"
+          running = false if response['result'] == 'failed' && options.failfast?
+        else
+          logger.info "Run #{run_id} is now #{response["state"]} and has #{response["result"]}"
+          running = false
         end
         Kernel.sleep 5 if running
       end
@@ -184,10 +182,6 @@ module RainforestCli
       end
 
       url = client.get('/uploads', {}, retries_on_failures: true)
-      unless url
-        logger.fatal "Failed to upload file #{app_source_url}. Please, check your API token."
-        exit 1
-      end
       data = File.read(app_source_url)
       logger.info 'Uploading app source file, this operation may take few minutes...'
       response_code = upload_file(url, data)

data/lib/rainforest_cli/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module RainforestCli
-  VERSION = '1.10.2'
+  VERSION = '1.10.3'
 end

data/spec/rainforest_cli/csv_importer_spec.rb

@@ -32,7 +32,7 @@ describe RainforestCli::CSVImporter do
                                         name: 'variables',
                                         description: 'variables',
                                         columns: columns,
-                                      })
+                                      }, retries_on_failures: true)
                                 .and_return success_response
 
         expect(http_client).to receive(:post)

data/spec/rainforest_cli/http_client_spec.rb

@@ -1,79 +1,87 @@
 # frozen_string_literal: true
 describe RainforestCli::HttpClient do
-  subject { described_class.new({ token: 'foo' }) }
+  let(:path) { '/my/path' }
+  let(:success_response) { instance_double('HTTParty::Response', code: 200, body: {'success'=>'true'}.to_json) }
 
-  describe '#get' do
-    describe 'maximum tolerated exceptions' do
-      let(:url) { 'http://some.url.com' }
+  [:get, :post, :delete].each do |m|
+    describe "##{m}" do
+      subject { described_class.new({ token: 'foo' }) }
+
+      it 'makes the correct type of request' do
+        expect(HTTParty).to receive(m).and_return(success_response)
+        subject.public_send(m, path)
+      end
+    end
+  end
 
+  describe '#request' do
+    let(:method) { :get }
+    let(:body) { { foo: :bar } }
+    let(:options) { {} }
+    subject { described_class.new({ token: 'foo' }).request(method, path, body, options) }
+
+    describe 'maximum tolerated exceptions' do
       before do
-        allow(HTTParty).to receive(:get).and_raise(SocketError)
+        allow(HTTParty).to receive(method).and_raise(SocketError)
       end
 
       context 'retries_on_failures omitted' do
         it 'raises the error on the first exception' do
-          expect(HTTParty).to receive(:get).once
-          expect { subject.get(url) }.to raise_error(Http::Exceptions::HttpException)
+          expect(HTTParty).to receive(method).once
+          expect { subject }.to raise_error(Http::Exceptions::HttpException)
         end
       end
 
       context 'retries_on_failures == false' do
+        let(:options) { { retries_on_failures: false } }
+
         it 'raises the error on the first exception' do
-          expect(HTTParty).to receive(:get).once
-          expect { subject.get(url, {}, retries_on_failures: false) }.to raise_error(Http::Exceptions::HttpException)
+          expect(HTTParty).to receive(method).once
+          expect { subject }.to raise_error(Http::Exceptions::HttpException)
         end
       end
 
       context 'retries_on_failures == true' do
+        let(:options) { { retries_on_failures: true } }
         let(:response) { instance_double('HTTParty::Response', code: 200, body: {foo: :bar}.to_json) }
         let(:delay_interval) { described_class::RETRY_INTERVAL }
-        subject { described_class.new({ token: 'foo' }).get(url, {}, retries_on_failures: true) }
 
         it 'it sleeps after failures before a retry' do
-          expect(HTTParty).to receive(:get).and_raise(SocketError).once.ordered
-          expect(HTTParty).to receive(:get).and_return(response).ordered
-          expect(Kernel).to receive(:sleep).with(delay_interval).once
+          expect(HTTParty).to receive(method).and_raise(SocketError).once.ordered
+          expect(HTTParty).to receive(method).and_return(response).ordered
+          expect(Kernel).to receive(:sleep)
           expect { subject }.to_not raise_error
         end
 
         it 'sleeps for longer periods with repeated exceptions' do
-          expect(HTTParty).to receive(:get).and_raise(SocketError).exactly(3).times.ordered
-          expect(HTTParty).to receive(:get).and_return(response).ordered
-          expect(Kernel).to receive(:sleep).with(delay_interval).once
-          expect(Kernel).to receive(:sleep).with(delay_interval * 2).once
-          expect(Kernel).to receive(:sleep).with(delay_interval * 3).once
+          expect(HTTParty).to receive(method).and_raise(SocketError).exactly(3).times.ordered
+          expect(HTTParty).to receive(method).and_return(response).ordered
+          expect(Kernel).to receive(:sleep).exactly(3).times
           expect { subject }.to_not raise_error
         end
 
         it 'returns the response upon success' do
-          expect(HTTParty).to receive(:get).and_raise(SocketError).once.ordered
-          expect(HTTParty).to receive(:get).and_return(response).ordered
-          expect(Kernel).to receive(:sleep).with(delay_interval).once
+          expect(HTTParty).to receive(method).and_raise(SocketError).once.ordered
+          expect(HTTParty).to receive(method).and_return(response).ordered
+          expect(Kernel).to receive(:sleep).once
           expect(subject).to eq(JSON.parse(response.body))
         end
       end
     end
 
-    describe 'non 200 codes' do
-      context '404 not found'do
-        let(:url) { 'http://some.url.com' }
-        let(:response) { instance_double('HTTParty::Response', code: 404, body: {'error'=>'some error', 'type'=>'some type'}.to_json) }
-        subject { described_class.new({ token: 'foo' }).get(url, {}) }
-
-        before do
-          allow(HTTParty).to receive(:get).and_raise(SocketError)
-        end
+    describe 'unsuccessful status codes' do
+      let(:url) { 'http://some.url.com' }
+      let(:bad_response) { instance_double('HTTParty::Response', code: 404, body: {'error'=>'some error', 'type'=>'some type'}.to_json) }
 
-        it 'gets an error 404 and prints the error' do
-          expect(HTTParty).to receive(:get).and_return(response)
-          expect_any_instance_of(Logger).to receive(:warn).with('Status Code: 404, {"error":"some error","type":"some type"}')
-          expect(subject)
-        end
+      before do
+        allow(HTTParty).to receive(method).and_raise(SocketError)
+      end
 
-        it 'returns nil' do
-          expect(HTTParty).to receive(:get).and_return(response)
-          expect(subject).to eq(nil)
-        end
+      it 'gets an error 404 and prints the error and exits' do
+        expect(HTTParty).to receive(method).and_return(bad_response)
+        expect_any_instance_of(Logger).to receive(:fatal).with(a_string_including('Non 200 code received'))
+        expect_any_instance_of(Logger).to receive(:fatal).with(a_string_including(bad_response.body.to_s))
+        expect { subject }.to raise_error(SystemExit)
       end
     end
   end

data/spec/rainforest_cli/runner_spec.rb

@@ -86,18 +86,6 @@ describe RainforestCli::Runner do
         }
       end
 
-      it 'errors out and exits if valid file but invalid token' do
-        File.should_receive(:exist?).with('fobar.ipa') { true }
-        subject.client.should_receive(:get).with('/uploads', {}, retries_on_failures: true) { nil }
-        expect_any_instance_of(Logger).to receive(:fatal).with(
-          'Failed to upload file fobar.ipa. Please, check your API token.')
-        expect do
-          subject.upload_app('fobar.ipa')
-        end.to raise_error(SystemExit) { |error|
-          expect(error.status).to eq 1
-        }
-      end
-
       it 'errors out and exits if was not possible to upload the file' do
         File.should_receive(:exist?).with('fobar.ipa') { true }
         File.should_receive(:read).with('fobar.ipa') { 'File data' }

data/spec/rainforest_cli_spec.rb

@@ -210,19 +210,24 @@ describe RainforestCli do
         expect(described_class.start(valid_args)).to eq(true)
       end
     end
+  end
 
-    context 'a run where the server 500s after a while' do
-      before do
-        allow_any_instance_of(http_client).to receive(:post).and_return('id' => 1)
-        expect_any_instance_of(http_client).to receive(:get).twice.and_return(ok_progress)
-        expect_any_instance_of(http_client).to receive(:get)
-        expect_any_instance_of(http_client).to receive(:get).twice.and_return(ok_progress)
-        expect_any_instance_of(http_client).to receive(:get).and_return(complete_response)
-      end
+  context 'commands' do
+    let(:valid_args) { %w(some args) }
+    let(:command) { double(:command, call: true) }
+    let(:option_parser) { double(:option_parser, token: '123abc', validate!: true, command: 'some-cmd') }
 
-      it 'should return true' do
-        expect(described_class.start(valid_args)).to eq(true)
+    before do
+      allow(RainforestCli::OptionParser).to receive(:new) { option_parser }
+      allow(RainforestCli::Commands).to receive(:new).and_yield(command).and_return(command)
+    end
+
+    it 'we register all currently supported commands' do
+      RainforestCli::Commands::SUPPORTED_COMMANDS.each do |supported_command|
+        expect(command).to receive(:add).with(supported_command, kind_of(String))
       end
+
+      described_class.start(valid_args)
     end
   end
 end

data/spec/spec_helper.rb

@@ -15,9 +15,6 @@ RSpec.configure do |config|
   config.order = 'random'
 
   config.before do
-    # suppress output in terminal
-    allow_any_instance_of(Object).to receive(:puts)
-
     progressbar_mock = double('ProgressBar')
     allow(ProgressBar).to receive(:create).and_return(progressbar_mock)
     allow(progressbar_mock).to receive(:increment)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rainforest-cli
 version: !ruby/object:Gem::Version
-  version: 1.10.2
+  version: 1.10.3
 platform: ruby
 authors:
 - Russell Smith
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-11 00:00:00.000000000 Z
+date: 2016-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty