agile-proxy-jruby 0.1.25-jruby

data/spec/integration_spec_helper.rb

@@ -0,0 +1,16 @@
+require 'require_all'
+
+require 'agile_proxy'
+require_all 'spec/support/**/*.rb'
+require_all 'lib/agile_proxy/model'
+require_all 'spec/integration/helpers'
+require 'faker'
+RSpec.configure do |config|
+  config.include AgileProxy::TestServer, :type => :integration
+  config.before :all, :type => :integration do
+    start_test_servers
+    start_proxy_server
+    debug_me = true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+ENV['RACK_ENV'] ||= 'test'
+require 'pry'
+require 'active_record'
+require 'shoulda-matchers'
+require 'rack'
+require 'logger'
+require_relative './unit/agile_proxy/api/common_helper'
+require_relative './common_helper'
+require_relative '../lib/agile_proxy'
+environment = 'test'
+dbconfig    = YAML.load(File.read(AgileProxy.config.database_config_file))
+ActiveRecord::Base.establish_connection dbconfig[environment]
+
+AgileProxy.configure do |config|
+  config.logger = Logger.new(File.expand_path('../../log/test.log', __FILE__))
+end
+
+RSpec.configure do |config|
+  include AgileProxy::TestServer
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+
+  config.before :all do
+    start_test_servers
+  end
+
+  config.after :each do
+    AgileProxy.config.reset
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.syntax = :expect
+  end
+  config.include AgileProxy::Test::Api::Common, api_test: true
+  config.include AgileProxy::Test::Common
+end

data/spec/support/test_server.rb

@@ -0,0 +1,105 @@
+require 'faraday'
+require 'agile_proxy/cli'
+require 'socket'
+
+
+
+
+module AgileProxy
+  module TestServer
+    class DummyApi
+      def response(env)
+        [200, {}, "hello!"]
+      end
+    end
+    class Server
+      attr_accessor :server_port
+      def initialize(world)
+        @world = world
+        at_exit do
+          cleanup
+        end
+        #Thin::Logging.silent = true
+      end
+      def pids
+        @pids ||= []
+      end
+      def cleanup
+        until pids.empty?
+          begin
+            Process.kill('INT', pids.pop);
+          rescue Errno::ESRCH
+            #Do nothing
+          end
+        end
+      end
+      def available_port(qty = 1)
+        # use Addrinfo
+        results = []
+        sockets_opened = []
+        while results.length < qty
+          socket = Socket.new(:INET, :STREAM, 0)
+          socket.bind(Addrinfo.tcp("127.0.0.1", 0))
+          port = socket.local_address.ip_port
+          results.push port unless results.include? port
+          sockets_opened.push socket
+        end
+        sockets_opened.each do |socket|
+          socket.close
+        end
+        results
+      end
+
+      def ruby
+        RbConfig.ruby
+      end
+      def start_test_servers
+        ports = available_port(3)
+        puts "Starting test server on #{ports[0]}"
+        pids.push spawn(ruby, "echo_server.rb", '--address', 'localhost', '--port', "#{ports[0]}")
+        puts "Starting test server on #{ports[1]}"
+        pids.push spawn(ruby, "echo_server.rb", '--address', 'localhost', '--port', "#{ports[1]}", '--ssl')
+        puts "Starting test server on #{ports[2]}"
+        pids.push spawn({'STATUS_CODE' => '500'}, ruby, "echo_server.rb", '--address', 'localhost', '--port', "#{ports[2]}")
+        @world.instance_eval do
+          @http_url  = "http://localhost:#{ports.shift}"
+          @https_url = "https://localhost:#{ports.shift}"
+          @error_url = "http://localhost:#{ports.shift}"
+          @http_url_no_proxy = "http://localhost:#{server_port}"
+          @https_url_no_proxy = "https://localhost:#{server_port}"
+        end
+      end
+
+
+    end
+
+    def initialize(rspecParams=nil)
+
+    end
+    def proxy_port
+      3101
+    end
+    def api_port
+      3021
+    end
+    def server_port
+      3022
+    end
+
+
+    def start_test_servers
+      @test_servers = Server.new(self)
+      @test_servers.server_port = server_port
+      @test_servers.start_test_servers
+    end
+
+    def start_proxy_server
+      Thread.new do
+        cli = Cli.start(['start', proxy_port.to_s, server_port.to_s, api_port.to_s, '--env', 'test'])
+      end
+      sleep 10
+    end
+
+
+  end
+end

data/spec/unit/agile_proxy/api/applications_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require_relative './common_helper'
+require 'rack/test'
+
+describe AgileProxy::Api::Applications, api_test: true do
+  include Rack::Test::Methods
+  include AgileProxy::Test::Api::Common
+  let(:applications_assoc_class) { Class.new }
+
+  describe 'GET /users/1/applications' do
+    let(:applications_result) do
+      [
+        { username: 'user1', password: 'password1', name: 'application1', record_requests: true, user_id: current_user.id }.stringify_keys,
+        { username: 'user1', password: 'password2', name: 'application2', record_requests: true, user_id: current_user.id }.stringify_keys,
+        { username: 'user1', password: 'password3', name: 'application3', record_requests: true, user_id: current_user.id }.stringify_keys
+      ]
+    end
+    before :each do
+      expect(current_user).to receive(:applications).and_return(applications_assoc_class)
+      expect(applications_assoc_class).to receive(:page).and_return applications_assoc_class
+      expect(applications_assoc_class).to receive(:per).and_return applications_assoc_class
+      expect(applications_assoc_class).to receive(:padding).and_return applications_assoc_class
+      expect(applications_assoc_class).to receive(:total_count).and_return 3
+      expect(applications_assoc_class).to receive(:num_pages).and_return 1
+      expect(applications_assoc_class).to receive(:current_page).and_return 1
+      expect(applications_assoc_class).to receive(:next_page).and_return 1
+      expect(applications_assoc_class).to receive(:prev_page).and_return 1
+      expect(applications_assoc_class).to receive(:count).and_return 3
+      expect(applications_assoc_class).to receive(:as_json).and_return(applications_result)
+    end
+    it 'returns a populated array of applications' do
+      get '/v1/users/1/applications'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq('applications' => applications_result, 'total' => 3)
+    end
+  end
+  describe 'POST /users/1/applications' do
+    let(:create_attributes) { { username: 'user1', password: 'password', name: 'application1', record_requests: true } }
+    let(:to_be_created_attributes) { create_attributes.merge(user_id: current_user.id, record_requests: 'true').stringify_keys }
+    let(:created_attributes) { to_be_created_attributes }
+    let(:mock_application) { double('AgileProxy::Application', create_attributes) }
+    before :each do
+      expect(current_user).to receive(:applications).and_return applications_assoc_class
+      expect(applications_assoc_class).to receive(:create!).with(to_be_created_attributes).and_return(mock_application)
+      expect(mock_application).to receive(:as_json).and_return(to_be_created_attributes)
+    end
+    it 'Creates a new application and returns it' do
+      post '/v1/users/1/applications', create_attributes, 'Content-Type' => 'application/json'
+      expect(last_response.status).to eq(201)
+      expect(JSON.parse(last_response.body)).to eql(created_attributes)
+    end
+  end
+  describe 'DELETE /users/1/applications' do
+    before :each do
+      expect(current_user).to receive(:applications).and_return(applications_assoc_class)
+      expect(applications_assoc_class).to receive(:destroy_all)
+    end
+    it 'Should destroy all applications for the user' do
+      delete '/v1/users/1/applications'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eql(applications: [], total: 0)
+    end
+  end
+  describe '/users/1/applications/10' do
+    let(:persisted_attributes) { { username: 'user1', password: 'password', name: 'application10', record_requests: true, id: 10 } }
+    let(:mock_application) { double('AgileProxy::Application', persisted_attributes) }
+    before :each do
+      expect(current_user).to receive(:applications).and_return(applications_assoc_class)
+      expect(applications_assoc_class).to receive(:where).with(id: '10').and_return applications_assoc_class
+      expect(applications_assoc_class).to receive(:first).and_return mock_application
+      expect(mock_application).to receive(:as_json).with({}).and_return persisted_attributes
+    end
+    context 'GET' do
+      it 'Should retrieve the application from persistence store' do
+        get '/v1/users/1/applications/10'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eql(persisted_attributes)
+      end
+    end
+    context 'DELETE' do
+      it 'Should call destroy on the application found' do
+        expect(mock_application).to receive(:destroy)
+        delete '/v1/users/1/applications/10'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eql(persisted_attributes)
+      end
+    end
+    context 'PUT' do
+      let(:to_be_updated_attributes) { { username: 'user1', password: 'password', name: 'application10 new name', record_requests: 'true' }.stringify_keys }
+      let(:updated_attributes) { to_be_updated_attributes.merge(record_requests: true).stringify_keys }
+      it 'Should call update_attributes on the application found' do
+        expect(mock_application).to receive(:update_attributes).with(to_be_updated_attributes)
+        persisted_attributes.merge! updated_attributes
+        persisted_attributes.delete(:id) # We dont allow modification of the id
+        put '/v1/users/1/applications/10', to_be_updated_attributes
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body)).to eql(updated_attributes)
+
+      end
+    end
+  end
+end

data/spec/unit/agile_proxy/api/common_helper.rb

@@ -0,0 +1,31 @@
+module AgileProxy
+  module Test
+    module Api
+      # A common helper for all API unit tests
+      module Common
+        def self.included(base)
+          base.instance_eval do
+            before :each do
+              setup_active_record_environment!
+              def app
+                AgileProxy::Api::Root
+              end
+            end
+          end
+        end
+
+        def current_user
+          @__current_user ||= double('AgileProxy::User', id: 1, name: 'Test User')
+        end
+
+        def current_application
+          @__current_application ||= double('AgileProxy::Application', name: 'Default Application', id: 1)
+        end
+
+        def setup_active_record_environment!
+          allow(AgileProxy::User).to receive(:first).and_return current_user
+        end
+      end
+    end
+  end
+end

data/spec/unit/agile_proxy/api/recordings_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require_relative 'common_helper'
+require 'rack/test'
+
+describe AgileProxy::Api::Recordings, api_test: true do
+  include Rack::Test::Methods
+  include AgileProxy::Test::Api::Common
+  let(:applications_assoc_class) do
+    Class.new do
+    end
+  end
+  let(:recordings_assoc_class) do
+    Class.new do
+      def self.destroy_all
+      end
+    end
+  end
+  let(:application_instance) { applications_assoc_class.new }
+
+  before :each do
+    expect(current_user).to receive(:applications).and_return(applications_assoc_class)
+    expect(applications_assoc_class).to receive(:where).with(id: '1').and_return applications_assoc_class
+    expect(applications_assoc_class).to receive(:first).and_return application_instance
+    expect(application_instance).to receive(:recordings).and_return recordings_assoc_class
+
+  end
+  describe 'GET /users/1/applications/1/recordings' do
+    let(:recordings_result) do
+      [
+        {
+          application_id: 1,
+          request_headers: '{}',
+          request_body: '',
+          request_url: 'http://www.test.com/1',
+          request_method: 'GET',
+          response_headers: '{}',
+          response_body: '{}',
+          response_status: '200'
+        }.stringify_keys,
+        {
+          application_id: 1,
+          request_headers: '{}',
+          request_body: '',
+          request_url: 'http://www.test.com/2',
+          request_method: 'GET',
+          response_headers: '{}',
+          response_body: '{}',
+          response_status: '200'
+        }.stringify_keys,
+        {
+          application_id: 1,
+          request_headers: '{}',
+          request_body: '',
+          request_url: 'http://www.test.com/3',
+          request_method: 'GET',
+          response_headers: '{}',
+          response_body: '{}',
+          response_status: '200'
+        }.stringify_keys
+      ]
+    end
+    before :each do
+      expect(recordings_assoc_class).to receive(:page).and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:per).and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:padding).and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:total_count).and_return 3
+      expect(recordings_assoc_class).to receive(:num_pages).and_return 1
+      expect(recordings_assoc_class).to receive(:current_page).and_return 1
+      expect(recordings_assoc_class).to receive(:next_page).and_return 1
+      expect(recordings_assoc_class).to receive(:prev_page).and_return 1
+      expect(recordings_assoc_class).to receive(:count).and_return 3
+      expect(recordings_assoc_class).to receive(:as_json).with({}).and_return recordings_result
+
+    end
+    it 'returns a populated array of recordings' do
+      get '/v1/users/1/applications/1/recordings'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq('recordings' => recordings_result, 'total' => 3)
+    end
+  end
+  describe 'DELETE /users/1/applications/1/recordings' do
+    it 'Should destroy all applications for the user' do
+      expect(recordings_assoc_class).to receive(:destroy_all)
+      delete '/v1/users/1/applications/1/recordings'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eql(recordings: [], total: 0)
+    end
+  end
+  describe '/users/1/applications/1/recordings/10' do
+    let(:recording_instance) { recordings_assoc_class.new }
+    let(:persisted_attributes) { { request_headers: '', response_headers: {} } }
+    before :each do
+      expect(recordings_assoc_class).to receive(:where).with(id: '10').and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:first).and_return recording_instance
+      expect(recording_instance).to receive(:as_json).with({}).and_return persisted_attributes
+    end
+    context 'GET' do
+      it 'Should fetch an individual recording' do
+        get '/v1/users/1/applications/1/recordings/10'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eql(persisted_attributes)
+
+      end
+    end
+    context 'DELETE' do
+      it 'Should delete an individual recording' do
+        expect(recording_instance).to receive(:destroy)
+        delete '/v1/users/1/applications/1/recordings/10'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eql(persisted_attributes)
+      end
+    end
+  end
+
+end

data/spec/unit/agile_proxy/api/request_spec_recordings_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+require_relative 'common_helper'
+require 'rack/test'
+
+describe AgileProxy::Api::RequestSpecRecordings, api_test: true do
+  include Rack::Test::Methods
+  include AgileProxy::Test::Api::Common
+  let(:applications_assoc_class) do
+    Class.new do
+    end
+  end
+  let(:recordings_assoc_class) do
+    Class.new do
+      def self.destroy_all
+      end
+    end
+  end
+  let(:application_instance) { applications_assoc_class.new }
+
+  before :each do
+    expect(current_user).to receive(:applications).and_return(applications_assoc_class)
+    expect(applications_assoc_class).to receive(:where).with(id: '1').and_return applications_assoc_class
+    expect(applications_assoc_class).to receive(:first).and_return application_instance
+    expect(application_instance).to receive(:recordings).and_return recordings_assoc_class
+
+  end
+  describe 'GET /users/1/applications/1/recordings' do
+    let(:recordings_result) do
+      [
+          {
+              application_id: 1,
+              request_headers: '{}',
+              request_body: '',
+              request_url: 'http://www.test.com/1',
+              request_method: 'GET',
+              response_headers: '{}',
+              response_body: '{}',
+              response_status: '200',
+              request_spec_id: 2
+          }.stringify_keys,
+          {
+              application_id: 1,
+              request_headers: '{}',
+              request_body: '',
+              request_url: 'http://www.test.com/2',
+              request_method: 'GET',
+              response_headers: '{}',
+              response_body: '{}',
+              response_status: '200',
+              request_spec_id: 2
+          }.stringify_keys,
+          {
+              application_id: 1,
+              request_headers: '{}',
+              request_body: '',
+              request_url: 'http://www.test.com/3',
+              request_method: 'GET',
+              response_headers: '{}',
+              response_body: '{}',
+              response_status: '200',
+              request_spec_id: 2
+          }.stringify_keys
+      ]
+    end
+    before :each do
+      expect(recordings_assoc_class).to receive(:where).with(request_spec_id: '2').and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:page).and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:per).and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:padding).and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:total_count).and_return 3
+      expect(recordings_assoc_class).to receive(:num_pages).and_return 1
+      expect(recordings_assoc_class).to receive(:current_page).and_return 1
+      expect(recordings_assoc_class).to receive(:next_page).and_return 1
+      expect(recordings_assoc_class).to receive(:prev_page).and_return 1
+      expect(recordings_assoc_class).to receive(:count).and_return 3
+      expect(recordings_assoc_class).to receive(:as_json).with({}).and_return recordings_result
+
+    end
+    it 'returns a populated array of recordings' do
+      get '/v1/users/1/applications/1/request_specs/2/recordings'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq('recordings' => recordings_result, 'total' => 3)
+    end
+  end
+  describe 'DELETE /users/1/applications/1/request_specs/2/recordings' do
+    it 'Should destroy all applications for the request spec' do
+      expect(recordings_assoc_class).to receive(:destroy_all).with(request_spec_id: '2')
+      delete '/v1/users/1/applications/1/request_specs/2/recordings'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eql(recordings: [], total: 0)
+    end
+  end
+  describe '/users/1/applications/1/request_specs/2/recordings/10' do
+    let(:recording_instance) { recordings_assoc_class.new }
+    let(:persisted_attributes) { { request_headers: '', response_headers: {} } }
+    before :each do
+      expect(recordings_assoc_class).to receive(:where).with(request_spec_id: '2', id: '10').and_return recordings_assoc_class
+      expect(recordings_assoc_class).to receive(:first).and_return recording_instance
+      expect(recording_instance).to receive(:as_json).with({}).and_return persisted_attributes
+    end
+    context 'GET' do
+      it 'Should fetch an individual recording' do
+        get '/v1/users/1/applications/1/request_specs/2/recordings/10'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eql(persisted_attributes)
+
+      end
+    end
+    context 'DELETE' do
+      it 'Should delete an individual recording' do
+        expect(recording_instance).to receive(:destroy)
+        delete '/v1/users/1/applications/1/request_specs/2/recordings/10'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eql(persisted_attributes)
+      end
+    end
+  end
+
+end