RubyGems - scooter - Versions diffs - 0.0.0 → 3.2.19 - Mend

scooter 0.0.0 → 3.2.19

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (47) hide show

checksums.yaml +15 -0
data/.env +5 -0
data/.gitignore +47 -19
data/Gemfile +3 -0
data/HISTORY.md +1539 -0
data/README.md +69 -10
data/Rakefile +7 -0
data/docs/http_dispatchers.md +79 -0
data/lib/scooter.rb +11 -3
data/lib/scooter/httpdispatchers.rb +12 -0
data/lib/scooter/httpdispatchers/activity.rb +46 -0
data/lib/scooter/httpdispatchers/activity/v1/v1.rb +50 -0
data/lib/scooter/httpdispatchers/classifier.rb +376 -0
data/lib/scooter/httpdispatchers/classifier/v1/v1.rb +99 -0
data/lib/scooter/httpdispatchers/code_manager.rb +31 -0
data/lib/scooter/httpdispatchers/code_manager/v1/v1.rb +17 -0
data/lib/scooter/httpdispatchers/consoledispatcher.rb +132 -0
data/lib/scooter/httpdispatchers/httpdispatcher.rb +168 -0
data/lib/scooter/httpdispatchers/orchestrator/v1/v1.rb +87 -0
data/lib/scooter/httpdispatchers/orchestratordispatcher.rb +83 -0
data/lib/scooter/httpdispatchers/puppetdb/v4/v4.rb +51 -0
data/lib/scooter/httpdispatchers/puppetdbdispatcher.rb +390 -0
data/lib/scooter/httpdispatchers/rbac.rb +231 -0
data/lib/scooter/httpdispatchers/rbac/v1/directory_service.rb +68 -0
data/lib/scooter/httpdispatchers/rbac/v1/v1.rb +116 -0
data/lib/scooter/ldap.rb +349 -0
data/lib/scooter/ldap/ldap_fixtures.rb +60 -0
data/lib/scooter/middleware/rbac_auth_token.rb +35 -0
data/lib/scooter/utilities.rb +9 -0
data/lib/scooter/utilities/beaker_utilities.rb +41 -0
data/lib/scooter/utilities/string_utilities.rb +32 -0
data/lib/scooter/version.rb +3 -1
data/scooter.gemspec +23 -6
data/spec/scooter/beaker_utilities_spec.rb +53 -0
data/spec/scooter/httpdispatchers/activity/activity_spec.rb +218 -0
data/spec/scooter/httpdispatchers/classifier/classifier_spec.rb +542 -0
data/spec/scooter/httpdispatchers/code_manager/code-manager_spec.rb +67 -0
data/spec/scooter/httpdispatchers/consoledispatcher_spec.rb +80 -0
data/spec/scooter/httpdispatchers/httpdispatcher_spec.rb +91 -0
data/spec/scooter/httpdispatchers/middleware/rbac_auth_token_spec.rb +58 -0
data/spec/scooter/httpdispatchers/orchestratordispatcher_spec.rb +195 -0
data/spec/scooter/httpdispatchers/puppetdbdispatcher_spec.rb +246 -0
data/spec/scooter/httpdispatchers/rbac/rbac_spec.rb +387 -0
data/spec/scooter/string_utilities_spec.rb +83 -0
data/spec/spec_helper.rb +8 -0
metadata +270 -18
data/LICENSE.txt +0 -15

data/spec/scooter/httpdispatchers/code_manager/code-manager_spec.rb ADDED Viewed

@@ -0,0 +1,67 @@
+require 'spec_helper'
+describe Scooter::HttpDispatchers::CodeManager do
+  let(:api) {
+    class DummyClass
+      attr_accessor :connection
+    end
+    dummy = DummyClass.new.extend(Scooter::HttpDispatchers::CodeManager)
+    dummy.connection = double(Faraday::Connection)
+    dummy
+  }
+  let(:array) { ['environment one', 'environment two'] }
+  describe '.deploy_environments' do
+    it 'works when passing in an array' do
+      expect(api.connection).to receive_message_chain('url_prefix.port=').with(8170)
+      expect(api.connection).to receive(:post).with('/code-manager/v1/deploys')
+      expect{api.deploy_environments(array)}.not_to raise_error
+    end
+    it 'works when passed a value for wait' do
+      expect(api.connection).to receive_message_chain('url_prefix.port=').with(8170)
+      expect(api.connection).to receive(:post).with('/code-manager/v1/deploys')
+      expect{api.deploy_environments(array, true)}.not_to raise_error
+    end
+    context 'negative cases' do
+      it 'should fail with no arguements' do
+        expect{api.deploy_environments}.to raise_error(ArgumentError)
+      end
+      it 'should fail if wait is not a boolean' do
+        expect{api.deploy_environments(array, 'true')}.to raise_error(ArgumentError)
+      end
+    end
+  end
+  describe '.deploy_all_environments' do
+    it 'works with no arguments' do
+      expect(api.connection).to receive_message_chain('url_prefix.port=').with(8170)
+      expect(api.connection).to receive(:post).with('/code-manager/v1/deploys')
+      expect{api.deploy_all_environments}.not_to raise_error
+    end
+    it 'should work with wait value' do
+      expect(api.connection).to receive_message_chain('url_prefix.port=').with(8170)
+      expect(api.connection).to receive(:post).with('/code-manager/v1/deploys')
+      expect{api.deploy_all_environments(true)}.not_to raise_error
+    end
+    context 'negative cases' do
+      it 'fails if supplied two arguments' do
+        expect{api.deploy_all_environments(true, 'foo bar')}.to raise_error(ArgumentError)
+      end
+      it 'should fail if wait is not a boolean' do
+        expect{api.deploy_all_environments('true')}.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/scooter/httpdispatchers/consoledispatcher_spec.rb ADDED Viewed

@@ -0,0 +1,80 @@
+require 'spec_helper'
+module Scooter
+  describe HttpDispatchers::ConsoleDispatcher do
+    let(:host) {double('host')}
+    let(:credentials) { { login: username, password: password} }
+    let(:username) {'Ziggy'}
+    let(:password) {'Stardust'}
+    let(:mock_page) {double('mock_page')}
+    subject { HttpDispatchers::ConsoleDispatcher.new(host, credentials) }
+    context 'with a beaker host passed in' do
+      unixhost = { roles:     ['test_role'],
+                   'platform' => 'debian-7-x86_64' }
+      let(:host) { Beaker::Host.create('test.com', unixhost, {}) }
+      before do
+        expect(Scooter::Utilities::BeakerUtilities).to receive(:pe_ca_cert_file).and_return('cert file')
+        expect(Scooter::Utilities::BeakerUtilities).to receive(:get_public_ip).and_return('public_ip')
+        expect(subject).not_to be_nil
+      end
+      context '.signin with a page that returns an xcsrf token' do
+        let(:mock_page) { <<-XCSRF_PAGE
+            <!doctype html>
+              <head>
+                <meta name="__anti-forgery-token" content="xcsrf-token" />
+              </head>
+            </html>
+        XCSRF_PAGE
+        }
+        before do
+          index = subject.connection.builder.handlers.index(Faraday::Adapter::NetHttp)
+          subject.connection.builder.swap(index, Faraday::Adapter::Test) do |stub|
+            stub.post('/auth/login', "username=#{username}&password=#{password}") {[200, {}, '']}
+            stub.get('/') {[200, {}, mock_page]}
+          end
+        end
+        it 'sends the credentials' do
+          expect{subject.signin}.to_not raise_error
+        end
+        it 'sets the xcsrf token in the header' do
+          subject.signin
+          expect(subject.connection.headers['X-CSRF-Token']).to eq('xcsrf-token')
+        end
+      end
+      context '.signin with a page that has no xcsrf token' do
+        let(:mock_page) { <<-XCSRF_PAGE
+            <!doctype html>
+              <head>
+              </head>
+            </html>
+        XCSRF_PAGE
+        }
+        before do
+          index = subject.connection.builder.handlers.index(Faraday::Adapter::NetHttp)
+          subject.connection.builder.swap(index, Faraday::Adapter::Test) do |stub|
+            stub.post('/auth/login', "username=#{username}&password=#{password}") {[200, {}, '']}
+            stub.get('/') {[200, {}, mock_page]}
+          end
+        end
+        it 'does not raise an error' do
+          expect{subject.signin}.to_not raise_error
+        end
+        it 'There is no xcsrf token set' do
+          subject.signin
+          expect(subject.connection.headers['X-CSRF-Token']).to eq(nil)
+        end
+      end
+    end
+  end
+end

data/spec/scooter/httpdispatchers/httpdispatcher_spec.rb ADDED Viewed

@@ -0,0 +1,91 @@
+require 'spec_helper'
+module Scooter
+  describe HttpDispatchers::HttpDispatcher do
+    let(:host) {double('host')}
+    subject { HttpDispatchers::HttpDispatcher.new(host) }
+    context 'with a beaker host passed in' do
+      unixhost = { roles:     ['test_role'],
+                   'platform' => 'debian-7-x86_64' }
+      let(:host) { Beaker::Host.create('test.com', unixhost, {}) }
+      before do
+        expect(Scooter::Utilities::BeakerUtilities).to receive(:pe_ca_cert_file).and_return('cert file')
+        expect(Scooter::Utilities::BeakerUtilities).to receive(:pe_private_key).and_return('key file')
+        expect(Scooter::Utilities::BeakerUtilities).to receive(:pe_hostcert).and_return('host cert')
+        expect(OpenSSL::PKey).to receive(:read).and_return('Pkey')
+        expect(OpenSSL::X509::Certificate).to receive(:new).and_return('client_cert')
+        expect(Scooter::Utilities::BeakerUtilities).to receive(:get_public_ip).and_return('public_ip')
+        expect(subject).not_to be_nil
+      end
+      it 'sets the hostname correctly' do
+        expect(subject.connection.url_prefix.hostname).to eq('test.com')
+      end
+      it 'automatically has been configured for https' do
+        expect(subject.connection.url_prefix.scheme).to eq('https')
+      end
+      it 'automatically has a defined CA file' do
+        expect(subject.connection.ssl['ca_file']).to eq('cert file')
+      end
+      it 'automatically has a defined client key' do
+        expect(subject.connection.ssl['client_key']).to eq('Pkey')
+      end
+      it 'automatically has a defined client cert' do
+        expect(subject.connection.ssl['client_cert']).to eq('client_cert')
+      end
+      it 'has a URI::HTTPS object for a url_prefix' do
+        expect(subject.connection.url_prefix).to be_an_instance_of(URI::HTTPS)
+      end
+      context 'when it receives a 500 error' do
+        before do
+          index = subject.connection.builder.handlers.index(Faraday::Adapter::NetHttp)
+          subject.connection.builder.swap(index, Faraday::Adapter::Test) do |stub|
+            stub.get('/test/route') {[500,
+                                      {'content-type' => 'application/json;charset=UTF-8'},
+                                      "{ \"key\" : \"value\" }"]}
+          end
+        end
+        it 'has a correctly parsed body in the error' do
+          expect{subject.connection.get('/test/route')}.to raise_error do |error|
+            expect(error.response[:body]).to be_a(Hash)
+          end
+        end
+      end
+    end
+    context 'with a string passed in for initialization' do
+      let(:host) {'test.com'}
+      before do
+        expect(subject).not_to be_nil
+      end
+      it 'sets the hostname correctly for the dispatcher object' do
+        expect(subject.connection.url_prefix.host).to eq('test.com')
+      end
+      it 'does not set ssl when there are no ssl components to add' do
+        expect(subject.add_ssl_components_to_connection).to eq(nil)
+        expect(subject.connection.url_prefix.scheme).to eq('http')
+        expect(subject.connection.ssl['client_key']).to eq(nil)
+        expect(subject.connection.ssl['client_cert']).to eq(nil)
+        expect(subject.connection.ssl['ca_file']).to eq(nil)
+      end
+    end
+  end
+end

data/spec/scooter/httpdispatchers/middleware/rbac_auth_token_spec.rb ADDED Viewed

@@ -0,0 +1,58 @@
+require 'spec_helper'
+describe Faraday::RbacAuthToken do
+  let(:conn) { Faraday.new(:url => 'http://test.com/path') }
+  let(:dispatcher) { double('dispatcher') }
+  before do
+    conn.builder.insert(0, Faraday::RbacAuthToken, dispatcher)
+    conn.adapter :test do |stub|
+      stub.get('/path') {[200, {}, 'success']}
+    end
+  end
+  describe 'a dispatcher with no token' do
+    before do
+      allow(dispatcher).to receive(:token) { nil }
+      allow(dispatcher).to receive(:send_auth_token_as_query_param) { nil }
+    end
+    it 'sends the request without a token' do
+      expect(conn.get.env.url.query).to eq(nil)
+      expect(conn.get.env.request_headers['X-Authentication']).to eq(nil)
+      expect{conn.get}.not_to raise_error
+    end
+  end
+  describe 'a dispatcher with a token' do
+    before do
+      allow(dispatcher).to receive(:token) {'testingtoken'}
+      allow(dispatcher).to receive(:send_auth_token_as_query_param) { nil }
+    end
+    it 'sends the request with the token in an X-Authentication header' do
+      expect(conn.get.env.request_headers['X-Authentication']).to eq('testingtoken')
+    end
+  end
+  describe 'a dispatcher with a token as a query param' do
+    before do
+      allow(dispatcher).to receive(:token) { 'testingtoken' }
+      allow(dispatcher).to receive(:send_auth_token_as_query_param) { true }
+    end
+    it 'sends the request with the token as a query param' do
+      expect(conn.get.env.url.query).to eq('token=testingtoken')
+    end
+  end
+  describe 'a dispatcher with a token to be sent as a query param does not overwrite other params' do
+    before do
+      allow(dispatcher).to receive(:token) { 'testingtoken' }
+      allow(dispatcher).to receive(:send_auth_token_as_query_param) { true }
+    end
+    it 'sends the request with the token and other parameters' do
+      response = conn.get {|req| req.params[:extra_param] = 'extra_value'}
+      hashed_query = CGI.parse(response.env.url.query)
+      expect(hashed_query).to eq('token'=> ['testingtoken'], 'extra_param' => ['extra_value'])
+    end
+  end
+end

data/spec/scooter/httpdispatchers/orchestratordispatcher_spec.rb ADDED Viewed

@@ -0,0 +1,195 @@
+require 'spec_helper'
+describe Scooter::HttpDispatchers::OrchestratorDispatcher do
+  let(:host) {'host'}
+  let(:orchestrator_api) { Scooter::HttpDispatchers::OrchestratorDispatcher.new(host) }
+  let(:job_id) { random_string }
+  let(:environment) {random_string}
+  subject { orchestrator_api }
+  it 'should make requests on the correct port' do
+    expect(orchestrator_api.connection.url_prefix.port).to be(8143)
+  end
+  it 'should use the correct path prefix' do
+    expect(orchestrator_api.connection.url_prefix.path).to eq('/orchestrator')
+  end
+  describe '.list_jobs' do
+    it { is_expected.to respond_to(:list_jobs).with(0).arguments }
+    it { is_expected.to respond_to(:list_jobs).with(1).arguments }
+    it { is_expected.not_to respond_to(:list_jobs).with(2).arguments }
+    it 'should take a job_id' do
+      expect(orchestrator_api.connection).to receive(:get).with('v1/jobs')
+      expect{ orchestrator_api.list_jobs }.not_to raise_error
+    end
+  end
+  describe '.list_job_details' do
+    it { is_expected.not_to respond_to(:list_job_details).with(0).arguments }
+    it { is_expected.to respond_to(:list_job_details).with(1).arguments }
+    it 'should take a job_id' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/jobs/#{job_id}")
+      expect{ orchestrator_api.list_job_details(job_id) }.not_to raise_error
+    end
+  end
+  describe '.list_nodes_associated_with_job' do
+    it { is_expected.not_to respond_to(:list_nodes_associated_with_job).with(0).arguments }
+    it { is_expected.to respond_to(:list_nodes_associated_with_job).with(1).arguments }
+    it 'should take a job_id' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/jobs/#{job_id}/nodes")
+      expect{ orchestrator_api.list_nodes_associated_with_job(job_id) }.not_to raise_error
+    end
+  end
+  describe '.get_job_report' do
+    it { is_expected.not_to respond_to(:get_job_report).with(0).arguments }
+    it { is_expected.to respond_to(:get_job_report).with(1).arguments }
+    it 'should take a job_id' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/jobs/#{job_id}/report")
+      expect{ orchestrator_api.get_job_report(job_id) }.not_to raise_error
+    end
+  end
+  describe '.get_job_events' do
+    it { is_expected.not_to respond_to(:get_job_events).with(0).arguments }
+    it { is_expected.to respond_to(:get_job_events).with(1).arguments }
+    it 'should take a job_id' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/jobs/#{job_id}/events")
+      expect{ orchestrator_api.get_job_events(job_id) }.not_to raise_error
+    end
+  end
+  describe '.environment' do
+    it { is_expected.not_to respond_to(:environment).with(0).arguments }
+    it { is_expected.to respond_to(:environment).with(1).arguments }
+    it 'should take a environment name' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/environments/#{environment}")
+      expect{ orchestrator_api.environment(environment) }.not_to raise_error
+    end
+  end
+  describe '.list_applications' do
+    it { is_expected.not_to respond_to(:list_applications).with(0).arguments }
+    it { is_expected.to respond_to(:list_applications).with(1).arguments }
+    it 'should take a environment name' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/environments/#{environment}/applications")
+      expect{ orchestrator_api.list_applications(environment) }.not_to raise_error
+    end
+  end
+  describe '.list_app_instances' do
+    it { is_expected.not_to respond_to(:list_app_instances).with(0).arguments }
+    it { is_expected.to respond_to(:list_app_instances).with(1).arguments }
+    it 'should take a environment name' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/environments/#{environment}/instances")
+      expect{ orchestrator_api.list_app_instances(environment) }.not_to raise_error
+    end
+  end
+  describe '.deploy_environment' do
+    it { is_expected.not_to respond_to(:deploy_environment).with(0).arguments }
+    it { is_expected.to respond_to(:deploy_environment).with(1).arguments }
+    it { is_expected.to respond_to(:deploy_environment).with(2).arguments }
+    it 'should take an environment name' do
+      expect(orchestrator_api.connection).to receive(:post).with("v1/command/deploy")
+      expect{ orchestrator_api.deploy_environment(environment) }.not_to raise_error
+    end
+    it 'should take an environment and a opts hash' do
+      opts = {'noop' => true, 'concurency' => 5}
+      expect(orchestrator_api.connection).to receive(:post).with("v1/command/deploy")
+      expect{ orchestrator_api.deploy_environment(environment, opts) }.not_to raise_error
+    end
+  end
+  describe '.stop_job' do
+    it { is_expected.not_to respond_to(:stop_job).with(0).arguments }
+    it { is_expected.to respond_to(:stop_job).with(1).arguments }
+    it { is_expected.not_to respond_to(:stop_job).with(2).arguments }
+    it 'should take a job id' do
+      expect(orchestrator_api.connection).to receive(:post).with("v1/command/stop")
+      expect{ orchestrator_api.stop_job(job_id) }.not_to raise_error
+    end
+  end
+  describe '.plan_job' do
+    it { is_expected.not_to respond_to(:plan_job).with(0).arguments }
+    it { is_expected.to respond_to(:plan_job).with(1).arguments }
+    it { is_expected.to respond_to(:plan_job).with(2).arguments }
+    it 'should take an environment name' do
+      expect(orchestrator_api.connection).to receive(:post).with("v1/command/plan")
+      expect{ orchestrator_api.plan_job(environment) }.not_to raise_error
+    end
+    it 'should take an environment and a opts hash' do
+      opts = {'noop' => true, 'concurency' => 5}
+      expect(orchestrator_api.connection).to receive(:post).with("v1/command/plan")
+      expect{ orchestrator_api.plan_job(environment, opts) }.not_to raise_error
+    end
+  end
+  describe '.get_inventory' do
+    let(:certname) {'thisismycertname'}
+    it {is_expected.to respond_to(:get_inventory).with(0).arguments }
+    it {is_expected.to respond_to(:get_inventory).with(1).arguments }
+    it {is_expected.not_to respond_to(:get_inventory).with(2).arguments }
+    it 'should take a single certname' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/inventory/#{certname}")
+      expect{ orchestrator_api.get_inventory(certname) }.not_to raise_error
+    end
+    it 'should take no argument' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/inventory")
+      expect{ orchestrator_api.get_inventory }.not_to raise_error
+    end
+  end
+  describe '.nodes_connected_to_broker' do
+    let(:certnames) {['certnameone', 'certnametwo', 'certnamethree']}
+    it {is_expected.not_to respond_to(:nodes_connected_to_broker).with(0).arguments }
+    it {is_expected.to respond_to(:nodes_connected_to_broker).with(1).arguments }
+    it {is_expected.not_to respond_to(:nodes_connected_to_broker).with(2).arguments }
+    it 'should take an array of certnames' do
+      expect(orchestrator_api.connection).to receive(:post).with("v1/inventory")
+      expect{ orchestrator_api.nodes_connected_to_broker(certnames) }.not_to raise_error
+    end
+  end
+  describe '.get_status' do
+    it {is_expected.to respond_to(:get_status).with(0).arguments }
+    it {is_expected.not_to respond_to(:get_status).with(1).arguments }
+    it 'should take no argument' do
+      expect(orchestrator_api.connection).to receive(:get).with("v1/status")
+      expect{ orchestrator_api.get_status }.not_to raise_error
+    end
+  end
+end