rainforest-cli 1.2.0 → 1.2.1

data/spec/csv_importer_spec.rb

@@ -1,10 +1,19 @@
+# frozen_string_literal: true
 describe RainforestCli::CSVImporter do
   let(:csv_file) { "#{File.dirname(__FILE__)}/fixtures/variables.txt" }
 
   describe '.import' do
     subject { described_class.new('variables', csv_file, 'abc123') }
+    let(:progressbar_mock) { double('ProgressBar') }
+
+    before do
+      # suppress output in terminal
+      allow_any_instance_of(described_class).to receive(:print)
+      allow_any_instance_of(described_class).to receive(:puts)
+      allow(ProgressBar).to receive(:create).and_return(progressbar_mock)
+      allow(progressbar_mock).to receive(:increment)
+    end
 
-    let(:http_client) { double }
     let(:columns) { %w(email pass) }
 
     let(:success_response) do
@@ -14,12 +23,8 @@ describe RainforestCli::CSVImporter do
       }
     end
 
-    before do
-      RainforestCli::HttpClient.stub(:new).and_return(http_client)
-    end
-
     it 'should post the schema to the generators API' do
-      expect(http_client).to receive(:post)
+      expect_any_instance_of(RainforestCli::HttpClient).to receive(:post)
                               .with('/generators', {
                                       name: 'variables',
                                       description: 'variables',
@@ -27,7 +32,7 @@ describe RainforestCli::CSVImporter do
                                     })
                               .and_return success_response
 
-      expect(http_client).to receive(:post)
+      expect_any_instance_of(RainforestCli::HttpClient).to receive(:post)
                               .with('/generators/12345/rows', {
                                       data: {
                                         0 => 'russ@rainforestqa.com',
@@ -35,7 +40,7 @@ describe RainforestCli::CSVImporter do
                                       }
                                     }).and_return({})
 
-      expect(http_client).to receive(:post)
+      expect_any_instance_of(RainforestCli::HttpClient).to receive(:post)
                               .with('/generators/12345/rows', {
                                       data: {
                                         0 => 'bob@example.com',

data/spec/git_trigger_spec.rb

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
 describe RainforestCli::GitTrigger do
   subject { described_class }
 
   let(:default_dir) { __dir__ }
   let(:test_repo_dir) { File.join(Dir.tmpdir, 'raiforest-cli', 'test-repo') }
 
-  describe ".last_commit_message" do
+  describe '.last_commit_message' do
     around(:each) do |spec|
       default_dir = Dir.pwd
       FileUtils.mkdir_p test_repo_dir
@@ -17,37 +18,49 @@ describe RainforestCli::GitTrigger do
       end
     end
 
-    # Commented because it kills CI
-    xit "returns a string" do
-      expect(described_class.last_commit_message).to eq "Initial commit"
+    it 'returns a string' do
+      expect(described_class.last_commit_message).to eq 'Initial commit'
     end
   end
 
-  describe ".git_trigger_should_run?" do
-    it "returns true when @rainforest is in the string" do
+  describe '.git_trigger_should_run?' do
+    it 'returns true when @rainforest is in the string' do
       expect(described_class.git_trigger_should_run?('hello, world')).to eq false
       expect(described_class.git_trigger_should_run?('hello @rainforest')).to eq true
     end
   end
 
-  describe ".extract_hashtags" do
-    it "returns a list of hashtags" do
+  describe '.extract_hashtags' do
+    it 'returns a list of hashtags' do
       expect(described_class.extract_hashtags('hello, world')).to eq []
       expect(described_class.extract_hashtags('#hello, #world')).to eq []
       expect(described_class.extract_hashtags('@rainforest #hello, #world')).to eq ['hello', 'world']
       expect(described_class.extract_hashtags('#notForRainforest @rainforest #hello, #world')).to eq ['hello', 'world']
       expect(described_class.extract_hashtags('@rainforest #hello,#world')).to eq ['hello', 'world']
-      expect(described_class.extract_hashtags('@rainforest #dashes-work, #underscores_work #007')).to eq ['dashes-work', 'underscores_work', '007']
+      expect(described_class.extract_hashtags('@rainforest #dashes-work, #underscores_work #007'))
+        .to eq ['dashes-work', 'underscores_work', '007']
     end
   end
 
   def setup_test_repo
-    FileUtils.rm_rf File.join(test_repo_dir, "*")
-    [
-      "git init",
+    FileUtils.rm_rf File.join(test_repo_dir, '*')
+
+    commands = [
+      'git init',
       "git commit --allow-empty -m 'Initial commit'",
-    ].each do |cmd|
-        system cmd
-      end
+    ]
+
+    # Git must be set up each time on CircleCI
+    unless system 'git config --get user.email'
+      commands.unshift("git config --global user.email 'test@rainforestqa.com'")
+    end
+
+    unless system 'git config --get user.name'
+      commands.unshift("git config --global user.name 'Rainforest QA'")
+    end
+
+    commands.each do |cmd|
+      system cmd
+    end
   end
 end

data/spec/http_client_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+describe RainforestCli::HttpClient do
+  subject { described_class.new({ token: 'foo' }) }
+
+  describe '#get' do
+    describe 'maximum tolerated exceptions' do
+      let(:url) { 'http://some.url.com' }
+
+      before do
+        allow(HTTParty).to receive(:get).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, {}, retries_on_failures: false) }.to raise_error(Http::Exceptions::HttpException)
+        end
+      end
+
+      context 'retries_on_failures == false' do
+        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)
+        end
+      end
+
+      context 'retries_on_failures == true' do
+        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 { 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 { 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(subject).to eq(JSON.parse(response.body))
+        end
+      end
+    end
+  end
+end

data/spec/options_spec.rb

@@ -1,113 +1,107 @@
+# frozen_string_literal: true
 describe RainforestCli::OptionParser do
   subject { RainforestCli::OptionParser.new(args) }
 
-  describe "#initialize" do
-    context "importing csv file" do
-      let(:args) { ["--import-variable-csv-file", "some_file.csv"] }
-      its(:import_file_name) { should == "some_file.csv" }
+  describe '#initialize' do
+    context 'importing csv file' do
+      let(:args) { ['--import-variable-csv-file', 'some_file.csv'] }
+
+      its(:import_file_name) { should == 'some_file.csv' }
     end
 
-    context "test folder (when passed)" do
-      let(:args) { ["--test-folder", "/path/to/folder"] }
-      its(:test_folder) { should == "/path/to/folder" }
+    context 'test folder (when passed)' do
+      let(:args) { ['--test-folder', '/path/to/folder'] }
+      its(:test_folder) { should == '/path/to/folder' }
     end
 
-    context "importing name" do
-      let(:args) { ["--import-variable-name", "some_name"] }
-      its(:import_name) { should == "some_name" }
+    context 'importing name' do
+      let(:args) { ['--import-variable-name', 'some_name'] }
+      its(:import_name) { should == 'some_name' }
     end
 
-    context "run all tests" do
-      let(:args) { ["run", "all"] }
-      its(:tests) { should == ["all"]}
+    context 'run all tests' do
+      let(:args) { ['run', 'all'] }
+      its(:tests) { should == ['all']}
       its(:conflict) { should == nil}
     end
 
-    context "run from tags" do
-      let(:args) { ["run", "--tag", "run-me"] }
+    context 'run from tags' do
+      let(:args) { ['run', '--tag', 'run-me'] }
       its(:tests) { should == []}
-      its(:tags) { should == ["run-me"]}
-    end
-
-    context "run from folder" do
-      let(:args) { ["run", "--folder", "12"] }
-      its(:folder) { should == "12"}
+      its(:tags) { should == ['run-me']}
     end
 
-    context "only run in specific browsers" do
-      let(:args) { ["run", "--browsers", "ie8"] }
-      its(:browsers) { should == ["ie8"]}
+    context 'run from folder' do
+      let(:args) { ['run', '--folder', '12'] }
+      its(:folder) { should == '12'}
     end
 
-    context "raises errors with invalid browsers" do
-      let(:args) { ["run", "--browsers", "lulbrower"] }
-
-      it "raises an exception" do
-        expect{subject}.to raise_error(RainforestCli::BrowserException)
-      end
+    context 'only run in specific browsers' do
+      let(:args) { ['run', '--browsers', 'ie8'] }
+      its(:browsers) { should == ['ie8']}
     end
 
-    context "accepts multiple browsers" do
-      let(:args) { ["run", "--browsers", "ie8,chrome"] }
-      its(:browsers) { should == ["ie8", "chrome"]}
+    context 'accepts multiple browsers' do
+      let(:args) { ['run', '--browsers', 'ie8,chrome'] }
+      its(:browsers) { should == ['ie8', 'chrome']}
     end
 
-    context "it parses the --git-trigger flag" do
-      let(:args) { ["run", "--git-trigger", "all"] }
-      its(:tests) { should == ["all"]}
-      its(:git_trigger?) { should be_true }
+    context 'it parses the --git-trigger flag' do
+      let(:args) { ['run', '--git-trigger', 'all'] }
+      its(:tests) { should == ['all']}
+      its(:git_trigger?) { is_expected.to eq(true) }
     end
 
-    context "it parses the --fg flag" do
-      let(:args) { ["run", "--fg", "all"] }
-      its(:tests) { should == ["all"]}
-      its(:foreground?) { should be_true }
+    context 'it parses the --fg flag' do
+      let(:args) { ['run', '--fg', 'all'] }
+      its(:tests) { should == ['all']}
+      its(:foreground?) { is_expected.to eq(true) }
     end
 
-    context "it parses the api token" do
-      let(:args) { ["run", "--token", "abc",  "all"] }
-      its(:token) { should == "abc"}
+    context 'it parses the api token' do
+      let(:args) { ['run', '--token', 'abc', 'all'] }
+      its(:token) { should == 'abc'}
     end
 
-    context "it parses the conflict flag" do
-      context "when abort" do
-        let(:args) { ["run", "--conflict", "abort",  "all"] }
-        its(:conflict) { should == "abort"}
+    context 'it parses the conflict flag' do
+      context 'when abort' do
+        let(:args) { ['run', '--conflict', 'abort', 'all'] }
+        its(:conflict) { should == 'abort'}
       end
 
-      context "when abort-all" do
-        let(:args) { ["run", "--conflict", "abort-all", "all"]}
-        its(:conflict) { should == "abort-all" }
+      context 'when abort-all' do
+        let(:args) { ['run', '--conflict', 'abort-all', 'all']}
+        its(:conflict) { should == 'abort-all' }
       end
     end
 
-    context "it parses the fail-fast flag" do
-      let(:args) { ["run", "--fail-fast"] }
-      its(:failfast?) { should be_true }
+    context 'it parses the fail-fast flag' do
+      let(:args) { ['run', '--fail-fast'] }
+      its(:failfast?) { is_expected.to eq(true) }
     end
 
-    context "it parses the site-id flag" do
-      let(:args) { ["run", "--site-id", '3'] }
+    context 'it parses the site-id flag' do
+      let(:args) { ['run', '--site-id', '3'] }
       its(:site_id) { should eq 3 }
     end
 
-    context "it parses the environment-id flag" do
-      let(:args) { ["run", "--environment-id", '3'] }
+    context 'it parses the environment-id flag' do
+      let(:args) { ['run', '--environment-id', '3'] }
       its(:environment_id) { should eq 3 }
     end
 
-    context "it parses the custom-url flag" do
-      let(:args) { ["run", "--custom-url", 'http://ad-hoc.example.com'] }
+    context 'it parses the custom-url flag' do
+      let(:args) { ['run', '--custom-url', 'http://ad-hoc.example.com'] }
       its(:custom_url) { should eq 'http://ad-hoc.example.com' }
     end
 
-    context "it add a run description" do
-      let(:args) { ["run", "--description", 'test description'] }
+    context 'it add a run description' do
+      let(:args) { ['run', '--description', 'test description'] }
       its(:description) { should eq 'test description' }
     end
   end
 
-  describe "#validate!" do
+  describe '#validate!' do
     def does_not_raise_a_validation_exception
       expect do
         subject.validate!
@@ -120,36 +114,44 @@ describe RainforestCli::OptionParser do
       end.to raise_error(described_class::ValidationError)
     end
 
-    context "with valid arguments" do
+    context 'with valid arguments' do
       let(:args) { %w(--token foo) }
       it { does_not_raise_a_validation_exception }
     end
 
-    context "with missing token" do
+    context 'with missing token' do
       let(:args) { %w() }
       it { raises_a_validation_exception }
     end
 
-    context "with a custom url but no site id" do
+    context 'with a custom url but no site id' do
       let(:args) { %w(--token foo --custom-url http://www.example.com) }
       it { raises_a_validation_exception }
     end
 
-    context "with a import_file_name but no import name" do
+    context 'with a import_file_name but no import name' do
       let(:args) { %w(--token foo --import-variable-csv-file foo.csv) }
       it { raises_a_validation_exception }
     end
 
-    context "with a import_file_name and a import_name" do
-      context "for an existing file" do
+    context 'with a import_file_name and a import_name' do
+      context 'for an existing file' do
         let(:args) { %W(--token foo --import-variable-csv-file #{__FILE__} --import-variable-name my-var) }
         it { does_not_raise_a_validation_exception }
       end
 
-      context "for a non existing file" do
+      context 'for a non existing file' do
         let(:args) { %W(--token foo --import-variable-csv-file does_not_exist --import-variable-name my-var) }
         it { raises_a_validation_exception }
       end
     end
+
+    context 'with invalid browsers' do
+      let(:args) { %w{run --browsers lulbrowser --token foo} }
+
+      it 'raises an exception' do
+        expect { subject.validate! }.to raise_error(RainforestCli::OptionParser::BrowserException)
+      end
+    end
   end
 end

data/spec/rainforest-example/example_test.rfml

@@ -1,6 +1,7 @@
 #! example_test (Test ID - only edit if this test has not yet been uploaded)
 # title: Example Test
-# start_uri: /
+# tags: foo,bar,baz
+# start_uri: /start_uri
 
 This is a step action.
 This is a question?

data/spec/remote_tests_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+describe RainforestCli::RemoteTests do
+  subject { described_class.new('api_token') }
+
+  describe '#primary_key_dictionary' do
+    Test = Struct.new(:rfml_id, :id)
+
+    let(:test1) { Test.new('foo', 123) }
+    let(:test2) { Test.new('bar', 456) }
+    let(:test3) { Test.new('baz', 789) }
+    let(:tests) { [test1, test2, test3] }
+
+    before do
+      allow(subject).to receive(:tests).and_return(tests)
+    end
+
+    it "correctly formats the dictionary's keys and values" do
+      expect(subject.primary_key_dictionary)
+        .to include({'foo' => test1.id, 'bar' => test2.id, 'baz' => test3.id})
+    end
+  end
+end

data/spec/runner_spec.rb

@@ -1,14 +1,15 @@
+# frozen_string_literal: true
 describe RainforestCli::Runner do
   let(:args) { %w(run all) }
   let(:options) { RainforestCli::OptionParser.new(args) }
   subject { described_class.new(options) }
 
-  describe "#get_environment_id" do
-    context "with an invalid URL" do
+  describe '#get_environment_id' do
+    context 'with an invalid URL' do
       it 'errors out and exits' do
-        expect {
+        expect do
           subject.get_environment_id('some=weird')
-        }.to raise_error(SystemExit) { |error|
+        end.to raise_error(SystemExit) { |error|
           expect(error.status).to eq 2
         }
       end
@@ -16,27 +17,27 @@ describe RainforestCli::Runner do
 
     context 'on API error' do
       before do
-        allow(subject.client).to receive(:post).and_return( {"error"=>"Some API error"} )
+        allow(subject.client).to receive(:post).and_return({'error'=>'Some API error'})
       end
 
       it 'errors out and exits' do
-        expect_any_instance_of(Logger).to receive(:fatal).with("Error creating the ad-hoc URL: Some API error")
-        expect {
+        expect_any_instance_of(Logger).to receive(:fatal).with('Error creating the ad-hoc URL: Some API error')
+        expect do
           subject.get_environment_id('http://example.com')
-        }.to raise_error(SystemExit) { |error|
+        end.to raise_error(SystemExit) { |error|
           expect(error.status).to eq 1
         }
       end
     end
   end
 
-  describe "#url_valid?" do
+  describe '#url_valid?' do
     subject { super().url_valid?(url) }
     [
-      "http://example.org",
-      "https://example.org",
-      "http://example.org/",
-      "http://example.org?foo=bar",
+      'http://example.org',
+      'https://example.org',
+      'http://example.org/',
+      'http://example.org?foo=bar',
     ].each do |valid_url|
       context "#{valid_url}" do
         let(:url) { valid_url }
@@ -45,9 +46,9 @@ describe RainforestCli::Runner do
     end
 
     [
-      "ftp://example.org",
-      "example.org",
-      "",
+      'ftp://example.org',
+      'example.org',
+      '',
     ].each do |valid_url|
       context "#{valid_url}" do
         let(:url) { valid_url }