rainforest-cli 1.6.5 → 1.7.0

data/spec/{csv_importer_spec.rb → rainforest_cli/csv_importer_spec.rb}

@@ -1,22 +1,15 @@
 # frozen_string_literal: true
 describe RainforestCli::CSVImporter do
-  let(:csv_file) { "#{File.dirname(__FILE__)}/fixtures/variables.txt" }
+  let(:csv_file) { "#{File.dirname(__FILE__)}/../fixtures/variables.txt" }
 
   describe '.import' do
     subject { described_class.new('variables', csv_file, 'abc123') }
-
-    before do
-      # suppress output in terminal
-      allow_any_instance_of(described_class).to receive(:print)
-      allow_any_instance_of(described_class).to receive(:puts)
-    end
-
     let(:columns) { %w(email pass) }
 
     let(:success_response) do
       {
         'id' => 12345,
-        'columns' => columns.each_with_index.map { |col, i| { 'id' => i, 'name' => col } }
+        'columns' => columns.each_with_index.map { |col, i| { 'id' => i, 'name' => col } },
       }
     end
 
@@ -25,7 +18,7 @@ describe RainforestCli::CSVImporter do
                               .with('/generators', {
                                       name: 'variables',
                                       description: 'variables',
-                                      columns: columns.map {|col| { name: col } }
+                                      columns: columns.map {|col| { name: col } },
                                     })
                               .and_return success_response
 
@@ -33,16 +26,16 @@ describe RainforestCli::CSVImporter do
                               .with('/generators/12345/rows', {
                                       data: {
                                         0 => 'russ@rainforestqa.com',
-                                        1 => 'abc123'
-                                      }
+                                        1 => 'abc123',
+                                      },
                                     }).and_return({})
 
       expect_any_instance_of(RainforestCli::HttpClient).to receive(:post)
                               .with('/generators/12345/rows', {
                                       data: {
                                         0 => 'bob@example.com',
-                                        1 => 'hunter2'
-                                      }
+                                        1 => 'hunter2',
+                                      },
                                     }).and_return({})
 
       subject.import

data/spec/{http_client_spec.rb → rainforest_cli/http_client_spec.rb}

@@ -53,5 +53,28 @@ describe RainforestCli::HttpClient do
         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
+
+        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
+
+        it 'returns nil' do
+          expect(HTTParty).to receive(:get).and_return(response)
+          expect(subject).to eq(nil)
+        end
+      end
+    end
   end
 end

data/spec/rainforest_cli/junit_outputter_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'json'
+require 'stringio'
+
+describe RainforestCli::JunitOutputter do
+  let(:spec_folder) { File.expand_path(File.dirname(__FILE__) + '/..') }
+  let(:runs_json_results) { JSON.parse(File.read("#{spec_folder}/fixtures/runs_response.json")) }
+  let(:tests_json_results) { JSON.parse(File.read("#{spec_folder}/fixtures/tests_response.json")) }
+  let(:failed_test_json) { JSON.parse(File.read("#{spec_folder}/fixtures/failed_test_response.json")) }
+  let(:test_io) { StringIO.new }
+
+  describe '.build_test_suite' do
+
+    subject { described_class.new('abc123', runs_json_results, tests_json_results) }
+
+    before do
+      allow(subject.client).to receive(:get).and_return(failed_test_json)
+    end
+
+    context 'With a valid response' do
+      it 'Parses the response' do
+        subject.parse
+        subject.output(test_io)
+
+        expect(test_io.string).to include('name="Test Description"')
+        expect(test_io.string).to include('failures="2"')
+        expect(test_io.string).to include('This feedback should appear')
+        expect(test_io.string).not_to include("This feedback shouldn't "appear")
+      end
+    end
+  end
+end

data/spec/{options_spec.rb → rainforest_cli/options_spec.rb}

@@ -80,6 +80,12 @@ describe RainforestCli::OptionParser do
       its(:foreground?) { is_expected.to eq(true) }
     end
 
+    context 'it parses the --wait flag' do
+      let(:args) { ['run', '--wait', '12345'] }
+      its(:wait?) { is_expected.to be true }
+      its(:run_id) { is_expected.to eq 12345 }
+    end
+
     context 'it parses the api token' do
       let(:args) { ['run', '--token', 'abc', 'all'] }
       its(:token) { should == 'abc'}
@@ -172,5 +178,32 @@ describe RainforestCli::OptionParser do
         it { raises_a_validation_exception }
       end
     end
+
+    context 'with junit output but not in foreground mode' do
+      let(:args) { %w(run --token foo --junit-file some_file.xml) }
+      it { raises_a_validation_exception }
+    end
+
+    context 'with junit output and in foreground mode' do
+      let(:args) { %w(--token foo --junit-file some_file.xml --fg) }
+      it { does_not_raise_a_validation_exception }
+    end
+
+    context 'valdiating the report command' do
+      context 'with a valid junit and run_id' do
+        let(:args) { ['report', '--junit-file', 'somefile.xml', '--run-id', '12345', '--token', 'foo'] }
+        it {does_not_raise_a_validation_exception }
+      end
+
+      context 'with a junit but no run_id' do
+        let(:args) { ['report', '--junit-file', 'somefile.xml', '--token', 'foo'] }
+        it { raises_a_validation_exception }
+      end
+
+      context 'with a run_id but no junit' do
+        let(:args) { ['report', '--run-id', '12345', '--token', 'foo'] }
+      end
+    end
+
   end
 end

data/spec/rainforest_cli/reporter_spec.rb

@@ -0,0 +1,51 @@
+
+
+describe RainforestCli::Reporter do
+  let(:args) { %w(report --token abc123 --run-id 12345 --junit-file somefile.xml) }
+  let(:options) { RainforestCli::OptionParser.new(args) }
+
+  subject { described_class.new(options) }
+
+  describe '#report' do
+    context 'on /runs/{run_id}.json API error' do
+      before do
+        allow(subject.client).to receive(:get).with('/runs/12345.json').and_return({'error'=>'Some API error'})
+      end
+
+      it 'errors out and exits' do
+        expect_any_instance_of(Logger).to receive(:fatal).with('Error retrieving results for your run: Some API error')
+        expect do
+          subject.report
+        end.to raise_error(SystemExit) { |error|
+          expect(error.status).to eq 1
+        }
+      end
+
+    end
+
+    context 'on /runs/{run_id}/tests.json API error' do
+      before do
+        allow(subject.client).to receive(:get).with('/runs/12345.json').and_return({'total_tests'=>'1'})
+        allow(subject.client).to receive(:get).with('/runs/12345/tests.json?page_size=1').and_return({'error'=>'Some API error'})
+      end
+
+      it 'errors and exits' do
+        expect_any_instance_of(Logger).to receive(:fatal).with('Error retrieving test details for your run: Some API error')
+        expect do
+          subject.report
+        end.to raise_error(SystemExit) { |error|
+          expect(error.status).to eq 1
+        }
+      end
+
+    end
+
+    context 'with working API calls creates JunitOutputter' do
+      before do
+        allow(subject.client).to receive(:get).with('/runs/12345.json').and_return()
+        allow(subject.client).to receive(:get).with('/runs/12345/tests.json?page_size=1').and_return()
+      end
+    end
+
+  end
+end

data/spec/{test_files_spec.rb → rainforest_cli/test_files_spec.rb}

@@ -4,7 +4,7 @@ describe RainforestCli::TestFiles do
   subject { described_class.new(options) }
 
   describe '#test_data' do
-    let(:test_directory) { File.dirname(__FILE__) + '/rainforest-example' }
+    let(:test_directory) { File.dirname(__FILE__) + '/../rainforest-example' }
     let(:options) { instance_double('RainforestCli::Options', test_folder: test_directory, command: nil) }
 
     let(:rfml_test) { subject.test_data.first }

data/spec/rainforest_cli/test_parser/step_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+describe RainforestCli::TestParser::Step do
+  subject { described_class.new }
+  let(:screenshot_string) do
+    'Picture 1: {{ file.screenshot(./foo) }}. Picture 2: {{file.screenshot(bar/baz)   }}'
+  end
+
+  let(:download_string) do
+    'Download 1: {{ file.download(./foo) }}. Download 2: {{file.download(bar/baz)   }}'
+  end
+
+  shared_examples 'a method that detects step variables' do |att|
+    it 'correctly detects a screenshot step variable' do
+      subject[att] = screenshot_string
+      expect(subject.send(:"uploadable_in_#{att}"))
+        .to eq([['screenshot', './foo'], ['screenshot', 'bar/baz']])
+    end
+
+    it 'correctly detects the download step variable' do
+      subject[att] = download_string
+      expect(subject.send(:"uploadable_in_#{att}"))
+        .to eq([['download', './foo'], ['download', 'bar/baz']])
+    end
+  end
+
+  describe '#uploadable_in_action' do
+    it_behaves_like 'a method that detects step variables', :action
+  end
+
+  describe '#uploadable_in_response' do
+    it_behaves_like 'a method that detects step variables', :response
+  end
+
+  describe '#has_uploadable_files?' do
+    let(:action) { 'Regular action' }
+    let(:response) { 'Regular response' }
+    subject { described_class.new(action, response).has_uploadable_files? }
+
+    context 'with no uploadables' do
+      it { is_expected.to be(false) }
+    end
+
+    context 'uploadable in action' do
+      let(:action) { 'Action with uploadable {{ file.download(/foo) }}' }
+      it { is_expected.to be(true) }
+    end
+
+    context 'uploadable in response' do
+      let(:response) { 'Response with uploadable {{ file.download(/foo) }}' }
+      it { is_expected.to be(true) }
+    end
+  end
+end

data/spec/rainforest_cli/test_parser_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+describe RainforestCli::TestParser do
+  describe RainforestCli::TestParser::Parser do
+    subject { described_class.new(file_name) }
+
+    describe '#initialize' do
+      let(:file_name) { './spec/rainforest-example/example_test.rfml' }
+
+      it 'expands the file name path' do
+        test = subject.instance_variable_get(:@test)
+        expect(test.file_name).to eq(File.expand_path(file_name))
+      end
+    end
+  end
+end

data/spec/rainforest_cli/uploader/uploadable_parser_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+describe RainforestCli::Uploader::UploadableParser do
+  let(:rfml_test) { instance_double('RainforestCli::TestParser::Test', file_name: 'rfml_test_filename.rfml') }
+  let(:test_id) { 12345 }
+  let(:uploaded_files) { [] }
+  subject { described_class.new(rfml_test, test_id, uploaded_files) }
+
+  describe '#replace_paths_in_text' do
+    let(:file) { instance_double('File') }
+    let(:file_path) { 'path/to/my/file.ext' }
+    let(:file_id) { 9876 }
+    let(:file_sig) { 'abcdef' }
+    let(:aws_info) do
+      { 'file_id' => file_id, 'file_signature' => "#{file_sig}xyz123" }
+    end
+
+    before do
+      allow(subject).to receive(:test_directory).and_return('my/test/directory')
+      allow(File).to receive(:exist?).and_return(true)
+      allow(File).to receive(:open).and_return(file)
+      allow(subject).to receive(:get_aws_upload_info).with(file).and_return(aws_info)
+    end
+
+    context 'screenshot' do
+      let(:original_text) { "My screenshot is {{ file.screenshot(#{file_path}) }}" }
+      let(:match) { ['screenshot', file_path] }
+      let(:expected_text) { "My screenshot is {{ file.screenshot(#{file_id}, #{file_sig}) }}" }
+
+      it 'replaces the screenshot variable arguments with the correct values' do
+        expect(subject.replace_paths_in_text(original_text, match)).to eq(expected_text)
+      end
+    end
+
+    context 'download' do
+      let(:original_text) { "My download is {{ file.download(#{file_path}) }}" }
+      let(:match) { ['download', file_path] }
+      let(:file_name) { File.basename(file_path) }
+      let(:expected_text) { "My download is {{ file.download(#{file_id}, #{file_sig}, #{file_name}) }}" }
+
+      it 'replaces the download variable arguments with the correct values' do
+        expect(subject.replace_paths_in_text(original_text, match)).to eq(expected_text)
+      end
+    end
+
+    context 'file does not exist' do
+      let(:original_text) { "My download is {{ file.download(#{file_path}) }}" }
+      let(:match) { ['download', file_path] }
+      let(:file_name) { File.basename(file_path) }
+
+      before do
+        allow(File).to receive(:exist?).and_call_original # remove stub in previous before block
+        expect(File).to receive(:exist?).with(a_string_including(file_path)).and_return(false)
+      end
+
+      it 'warns the user and does not replace the variable values' do
+        expect_any_instance_of(Logger).to receive(:warn).with(a_string_including(rfml_test.file_name))
+        expect_any_instance_of(Logger).to receive(:warn).with(a_string_including(file_name))
+        expect(subject.replace_paths_in_text(original_text, match)).to eq(original_text)
+      end
+    end
+  end
+
+  describe '#upload_to_rainforest' do
+    let(:file_path) { 'test_file.txt' }
+    let(:mime_type) { 'text/plain' }
+    let(:size) { 4545 }
+    let(:file) { instance_double('File', path: file_path, size: size) }
+    let(:digest) { 'myDigest' }
+
+    before do
+      allow(subject).to receive(:file_digest).with(file).and_return(digest)
+      allow(MimeMagic).to receive(:by_path).with(file).and_return(mime_type)
+    end
+
+    it 'uploads the correct metadata to Rainforest' do
+      expect(RainforestCli.http_client).to receive(:post) do |url, params|
+        expect(url).to include(test_id.to_s)
+        expect(params).to include(mime_type: mime_type, size: size, name: file_path, digest: digest)
+      end.and_return({ 'aws_url' => 'http://aws.amazon.com/lol' })
+
+      subject.upload_to_rainforest(file)
+    end
+  end
+end

data/spec/{uploader_spec.rb → rainforest_cli/uploader_spec.rb}

@@ -11,7 +11,7 @@ describe RainforestCli::Uploader do
 
   describe '#upload' do
     context 'with new tests' do
-      let(:test_directory) { File.expand_path(File.join(__FILE__, '../validation-examples/correct_embeds')) }
+      let(:test_directory) { File.expand_path(File.dirname(__FILE__) + '/../validation-examples/correct_embeds') }
       let(:rf_test_double) { instance_double('Rainforest::Test', id: 123) }
 
       before do
@@ -27,7 +27,7 @@ describe RainforestCli::Uploader do
   end
 
   describe 'uploaded test object' do
-    let(:test_directory) { File.expand_path(File.join(__FILE__, '../rainforest-example')) }
+    let(:test_directory) { File.expand_path(File.dirname(__FILE__) + '/../rainforest-example') }
     let(:test_double) { instance_double('Rainforest::Test', id: 123) }
 
     before do

data/spec/{validator_spec.rb → rainforest_cli/validator_spec.rb}

@@ -30,7 +30,7 @@ describe RainforestCli::Validator do
 
     context 'with parsing errors' do
       let(:notification_method) { :parsing_error_notification }
-      let(:test_directory) { File.expand_path(File.join(__FILE__, '../validation-examples/parse_errors')) }
+      let(:test_directory) { File.expand_path(File.dirname(__FILE__) + '/../validation-examples/parse_errors') }
 
       context 'no rfml id' do
         let(:correct_file_name) { 'no_rfml_id.rfml' }
@@ -55,7 +55,7 @@ describe RainforestCli::Validator do
 
     context 'with a incorrect embedded RFML ID' do
       let(:notification_method) { :nonexisting_embedded_id_notification }
-      let(:test_directory) { File.expand_path(File.join(__FILE__, '../validation-examples/missing_embeds')) }
+      let(:test_directory) { File.expand_path(File.dirname(__FILE__) + '/../validation-examples/missing_embeds') }
 
       context 'the file containing in the incorrect id' do
         let(:correct_file_name) { 'incorrect_test.rfml' }
@@ -69,7 +69,7 @@ describe RainforestCli::Validator do
     end
 
     context 'with circular embeds' do
-      let(:test_directory) { File.expand_path(File.join(__FILE__, '../validation-examples/circular_embeds')) }
+      let(:test_directory) { File.expand_path(File.dirname(__FILE__) + '/../validation-examples/circular_embeds') }
       let(:file_name_a) { File.join(test_directory, 'test1.rfml') }
       let(:file_name_b) { File.join(test_directory, 'test2.rfml') }
 
@@ -87,7 +87,7 @@ describe RainforestCli::Validator do
     it_behaves_like 'it detects all the correct errors'
 
     context 'when multiple tests have the same rfml_ids' do
-      let(:test_directory) { File.expand_path(File.join(__FILE__, '../validation-examples/duplicate_rfml_ids')) }
+      let(:test_directory) { File.expand_path(File.dirname(__FILE__) + '/../validation-examples/duplicate_rfml_ids') }
       let(:options) { instance_double('RainforestCli::Options', test_folder: test_directory, token: 'api_token', command: '') }
 
       subject { described_class.new(options) }
@@ -102,7 +102,6 @@ describe RainforestCli::Validator do
         expect { subject.validate }.to raise_error(SystemExit)
       end
 
-
       context 'when invalid' do
         before do
           allow(subject).to receive(:invalid?).and_return(true)
@@ -110,7 +109,7 @@ describe RainforestCli::Validator do
         it 'exits 1' do
           begin
             subject.validate
-            fail "validate did not exit with status 1"
+            fail 'validate did not exit with status 1'
           rescue SystemExit => e
             expect(e.status).to eq(1)
           end
@@ -125,7 +124,7 @@ describe RainforestCli::Validator do
     it_behaves_like 'it detects all the correct errors'
 
     context 'without a token option' do
-      let(:test_directory) { File.expand_path(File.join(__FILE__, '../validation-examples')) }
+      let(:test_directory) { File.expand_path(File.dirname(__FILE__) + '/../validation-examples') }
       let(:options) { instance_double('RainforestCli::Options', test_folder: test_directory, token: nil, command: '') }
       subject { described_class.new(options) }