agile-proxy 0.1.0

data/spec/integration_spec_helper.rb

@@ -0,0 +1,18 @@
+require 'require_all'
+require 'airborne'
+
+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|
+  include AgileProxy::TestServer
+  config.before :all do
+    start_test_servers
+  end
+
+end
+Airborne.configure do |config|
+  config.base_url = 'http://localhost:3020'
+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,75 @@
+require 'eventmachine'
+require 'thin'
+require 'faraday'
+
+module Thin
+  module Backends
+    class TcpServer
+      def get_port
+        # seriously, eventmachine, how hard does getting a port have to be?
+        Socket.unpack_sockaddr_in(EM.get_sockname(@signature)).first
+      end
+    end
+  end
+end
+
+module AgileProxy
+  module TestServer
+    def initialize
+      Thin::Logging.silent = true
+    end
+
+    def start_test_servers
+      q = Queue.new
+      Thread.new do
+        EM.run do
+          echo = echo_app_setup
+
+          http_server = start_server(echo)
+          q.push http_server.backend.get_port
+
+          https_server = start_server(echo, true)
+          q.push https_server.backend.get_port
+
+          echo_error = echo_app_setup(500)
+          error_server = start_server(echo_error)
+          q.push error_server.backend.get_port
+        end
+      end
+
+      @http_url  = "http://localhost:#{q.pop}"
+      @https_url = "https://localhost:#{q.pop}"
+      @error_url = "http://localhost:#{q.pop}"
+    end
+
+    def echo_app_setup(response_code = 200)
+      counter = 0
+      proc do |env|
+        req_body = env['rack.input'].read
+        request_info = "#{env['REQUEST_METHOD']} #{env['PATH_INFO']}"
+        res_body = request_info
+        res_body += "\n#{req_body}" unless req_body.empty?
+        counter += 1
+        [
+          response_code,
+          { 'HTTP-X-EchoServer' => request_info,
+            'HTTP-X-EchoCount' => "#{counter}" },
+          [res_body]
+        ]
+      end
+    end
+
+    def start_server(echo, ssl = false)
+      http_server = Thin::Server.new '127.0.0.1', 0, echo
+      if ssl
+        http_server.ssl = true
+        http_server.ssl_options = {
+          private_key_file: File.expand_path('../../fixtures/test-server.key', __FILE__),
+          cert_chain_file: File.expand_path('../../fixtures/test-server.crt', __FILE__)
+        }
+      end
+      http_server.start
+      http_server
+    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_specs_spec.rb

@@ -0,0 +1,159 @@
+require 'spec_helper'
+require_relative 'common_helper'
+require 'rack/test'
+
+describe AgileProxy::Api::RequestSpecs, api_test: true do
+  include Rack::Test::Methods
+  include AgileProxy::Test::Api::Common
+  let(:applications_assoc_class) do
+    Class.new do
+    end
+  end
+  let(:request_spec_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).at_least(:once).and_return(applications_assoc_class)
+    expect(applications_assoc_class).to receive(:where).with(id: '1').at_least(:once).and_return applications_assoc_class
+    expect(applications_assoc_class).to receive(:first).at_least(:once).and_return application_instance
+    expect(application_instance).to receive(:request_specs).and_return request_spec_assoc_class
+  end
+  let(:default_json_spec) { { include: { response: { except: [:created_at, :updated_at] } } } }
+
+  # def mock_collection_data
+  #   @__all_request_specs ||= [double('HttpFlexiblePrAgileProxy', :id => 1),double('AgileProxy::ReAgileProxy=> 2),double('AgileProxy::RequestSpAgileProxyeach do |d|
+  #     allow(d).to receive(:as_json).with(default_json_spec).and_return({:spec => "Spec #{d.id}"}.as_json)
+  #   end
+  # end
+  # def mock_collection_association
+  #   return @__mock_collection_association if @__mock_collection_association.present?
+  #   @__mock_collection_association = double('Mock Association')
+  #   @__mock_collection_association.tap do |o|
+  #     allow(o).to receive(:total_count).and_return 3
+  #     allow(o).to receive(:num_pages).and_return 1
+  #     allow(o).to receive(:current_page).and_return 1
+  #     allow(o).to receive(:next_page).and_return nil
+  #     allow(o).to receive(:prev_page).and_return nil
+  #     allow(o).to receive(:page).and_return o
+  #     allow(o).to receive(:per).and_return o
+  #     allow(o).to receive(:padding).and_return o
+  #   end
+  #   allow(@__mock_collection_association).to receive(:as_json).with(default_json_spec).and_return(mock_collection_data.as_json(default_json_spec))
+  #   allow(@__mock_collection_association).to receive(:count).and_return 3
+  #   allow(@__mock_collection_association).to receive(:where) do |options|
+  #     if options.key?(:id)
+  #       mock_collection_data.select{|r| r.id.to_s == options[:id]}
+  #     else
+  #       throw "mock_collection_association called with an unknown where clause of #{where.to_json}"
+  #     end
+  #   end
+  #   @__mock_collection_association
+  # end
+  # def created_member(attrs)
+  #   double("AgileProxy::RequestSpec", attrs.merge({:as_json => {"spec" => attrs[:spec]}}))
+  # end
+  describe 'GET /users/1/applications/1/request_specs' do
+    let(:request_specs_result) do
+      [{ 'spec' => 'Spec 1' }, { 'spec' => 'Spec 2' }, { 'spec' => 'Spec 3' }]
+    end
+    before :each do
+      expect(request_spec_assoc_class).to receive(:page).and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:per).and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:padding).and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:total_count).and_return 3
+      expect(request_spec_assoc_class).to receive(:num_pages).and_return 1
+      expect(request_spec_assoc_class).to receive(:current_page).and_return 1
+      expect(request_spec_assoc_class).to receive(:next_page).and_return 1
+      expect(request_spec_assoc_class).to receive(:prev_page).and_return 1
+      expect(request_spec_assoc_class).to receive(:count).and_return 3
+      expect(request_spec_assoc_class).to receive(:as_json).with(default_json_spec).and_return request_specs_result
+    end
+    it 'returns a populated array of request specs' do
+      get '/v1/users/1/applications/1/request_specs'
+      expect(last_response.status).to eq(200)
+      expect(JSON.parse(last_response.body)).to eq('request_specs' => [{ 'spec' => 'Spec 1' }, { 'spec' => 'Spec 2' }, { 'spec' => 'Spec 3' }], 'total' => 3)
+    end
+    it 'Should not list items from a different application'
+    it 'Should not list items that belong to a different user'
+  end
+  describe '/users/1/applications/1/request_specs/2' do
+    let(:request_spec_instance) { request_spec_assoc_class.new }
+    let(:persisted_attributes) { { user_id: 1, application_id: 1, url: 'http://www.test.com', http_method: 'GET' } }
+    before :each do
+      expect(request_spec_assoc_class).to receive(:where).with(id: '2').and_return request_spec_assoc_class
+      expect(request_spec_assoc_class).to receive(:first).and_return request_spec_instance
+      expect(request_spec_instance).to receive(:as_json).with(default_json_spec).and_return persisted_attributes
+    end
+    describe 'GET' do
+      it 'returns a single item in json format' do
+        get '/v1/users/1/applications/1/request_specs/2'
+        expect(last_response.status).to eq(200)
+        expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+      end
+      it 'Should not find a request spec which does not belong to the application specified'
+      it 'Should not find a request spec which does not belong to the user specified'
+    end
+    describe 'PUT' do
+      it 'Should update an existing item with the attributes given' do
+        expect(current_user).to receive(:id).and_return(1)
+        expect(application_instance).to receive(:id).and_return(1)
+        expect(request_spec_instance).to receive(:update_attributes).with(spec: 'Renamed Spec 2', user_id: 1, application_id: 1).and_return true
+        put '/v1/users/1/applications/1/request_specs/2', { spec: 'Renamed Spec 2' }.to_json, 'CONTENT_TYPE' => 'application/json'
+        expect(last_response.status).to eq 200
+        expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)  # Note that the mocked update_attributes doesnt actually update so the original json is expected
+      end
+    end
+    describe 'DELETE' do
+      it 'Should delete the existing item and return it in json form' do
+        expect(request_spec_instance).to receive(:destroy)
+        delete '/v1/users/1/applications/1/request_specs/2'
+        expect(last_response.status).to eq 200
+        expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+      end
+      it 'Should not allow deleting of other peoples request specs'
+    end
+  end
+  describe 'POST /users/1/applications/1/request_specs' do
+    let(:request_spec_instance) { request_spec_assoc_class.new }
+    let(:persisted_attributes) { { user_id: 1, application_id: 1, url: 'http://www.test.com', http_method: 'GET' } }
+    before :each do
+      expect(request_spec_instance).to receive(:as_json).with(default_json_spec).and_return(persisted_attributes)
+      expect(current_user).to receive(:id).and_return(1)
+      expect(application_instance).to receive(:id).and_return(1)
+    end
+    it 'Should create a new item with the correct attributes set' do
+      expect(request_spec_assoc_class).to receive(:create).with(spec: 'Spec 4', user_id: 1, application_id: 1).and_return request_spec_instance
+      post '/v1/users/1/applications/1/request_specs', { spec: 'Spec 4' }.to_json, 'CONTENT_TYPE' => 'application/json'
+      expect([200, 201]).to include(last_response.status)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+    end
+    it 'Should allow creating of a response object also' do
+      response_attributes = { name: 'Test Response', content: '<h1>Hello World</h1>', content_type: 'text/html', status_code: 200, headers: '{}', is_template: false }
+      expect(request_spec_assoc_class).to receive(:create).with(spec: 'Spec 4', user_id: 1, application_id: 1, response_attributes: Hashie::Mash.new(response_attributes)).and_return request_spec_instance
+      post '/v1/users/1/applications/1/request_specs', { spec: 'Spec 4', response: response_attributes }.to_json, 'CONTENT_TYPE' => 'application/json'
+      expect([200, 201]).to include(last_response.status)
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq(persisted_attributes)
+    end
+    it 'Should inform the router of the new entry'
+    it 'Should not allow the user to specify the user_id to prevent creating for a different user'
+    it 'Should not allow setting of an application_id which doesnt belong to the current user'
+  end
+  describe 'DELETE /users/1/applications/1/request_specs' do
+    before :each do
+      expect(request_spec_assoc_class).to receive(:delete_all)
+    end
+    it 'Should delete all request specs for the users application' do
+      delete '/v1/users/1/applications/1/request_specs'
+      expect(JSON.parse(last_response.body).symbolize_keys).to eq(request_specs: [], total: 0)
+
+    end
+  end
+  it 'Should not find other peoples request specs to update'
+  it 'Should not allow updates of the user_id to prevent changing ownership'
+  it 'Should not allow updates of the application_id to prevent changing ownership via the application'
+  it 'Should inform the router of the update if the spec or response has changed'
+end