appmap 0.35.0 → 0.37.2

data/spec/rails_spec_helper.rb

@@ -29,10 +29,10 @@ def run_cmd(*cmd, &failed)
   raise 'Command failed'
 end
 
-shared_context 'Rails app pg database' do
-  before(:all) do
-    raise 'you must set @fixure_dir' unless @fixture_dir
+shared_context 'Rails app pg database' do |fixture_dir|
+  let(:fixture_dir) { fixture_dir }
 
+  before(:all) do
     print_pg_logs = lambda do
       logs, = run_cmd 'docker-compose logs pg'
       puts "docker-compose logs for pg:"
@@ -40,7 +40,7 @@ shared_context 'Rails app pg database' do
       puts logs
     end
 
-    Dir.chdir @fixture_dir do 
+    Dir.chdir fixture_dir do 
       run_cmd 'docker-compose down -v'
       cmd = 'docker-compose up -d pg'
       run_cmd cmd
@@ -54,7 +54,7 @@ shared_context 'Rails app pg database' do
   after(:all) do
     if ENV['NOKILL'] != 'true'
       cmd = 'docker-compose down -v'
-      run_cmd cmd, chdir: @fixture_dir
+      run_cmd cmd, chdir: fixture_dir
     end
   end
 end

data/spec/railtie_spec.rb

@@ -1,43 +1,42 @@
 require 'rails_spec_helper'
 
 describe 'AppMap tracer via Railtie' do
-  before(:all) { @fixture_dir = 'spec/fixtures/rails_users_app' }
-  include_context 'Rails app pg database'
-  
-  let(:env) { {} }
+  include_context 'Rails app pg database', 'spec/fixtures/rails5_users_app' do 
+    let(:env) { {} }
 
-  let(:cmd) { %(docker-compose run --rm -e RAILS_ENV -e APPMAP app ./bin/rails r "puts Rails.configuration.appmap.enabled.inspect") }
-  let(:command_capture2) do
-    require 'open3'
-    Open3.capture3(env, cmd, chdir: @fixture_dir).tap do |result|
-      unless result[2] == 0
-        $stderr.puts <<~END
-          Failed to run rails_users_app container
-          <<< Output:
-          #{result[0]}
-          #{result[1]}
-          >>> End of output
-        END
-        raise 'Failed to run rails_users_app container'
+    let(:cmd) { %(docker-compose run --rm -e RAILS_ENV -e APPMAP app ./bin/rails r "puts Rails.configuration.appmap.enabled.inspect") }
+    let(:command_capture2) do
+      require 'open3'
+      Open3.capture3(env, cmd, chdir: fixture_dir).tap do |result|
+        unless result[2] == 0
+          warn <<~STDERR
+            Failed to run rails5_users_app container
+            <<< Output:
+            #{result[0]}
+            #{result[1]}
+            >>> End of output
+          STDERR
+          raise 'Failed to run rails5_users_app container'
+        end
       end
     end
-  end
-  let(:command_output) { command_capture2[0].strip }
-  let(:command_result) { command_capture2[2] }
-
-  it 'is disabled by default' do
-    expect(command_output).to eq('nil')
-  end
+    let(:command_output) { command_capture2[0].strip }
+    let(:command_result) { command_capture2[2] }
 
-  describe 'with APPMAP=true' do
-    let(:env) { { 'APPMAP' => 'true' } }
-    it 'is enabled' do
-      expect(command_output.split("\n")).to include('true')
+    it 'is disabled by default' do
+      expect(command_output).to eq('nil')
     end
-    context 'and RAILS_ENV=test' do
-      let(:env) { { 'APPMAP' => 'true', 'RAILS_ENV' => 'test' } }
-      it 'is disabled' do
-        expect(command_output).to eq('nil')
+
+    describe 'with APPMAP=true' do
+      let(:env) { { 'APPMAP' => 'true' } }
+      it 'is enabled' do
+        expect(command_output.split("\n")).to include('true')
+      end
+      context 'and RAILS_ENV=test' do
+        let(:env) { { 'APPMAP' => 'true', 'RAILS_ENV' => 'test' } }
+        it 'is disabled' do
+          expect(command_output).to eq('nil')
+        end
       end
     end
   end

data/spec/record_sql_rails4_pg_spec.rb

@@ -1,75 +1,74 @@
 require 'rails_spec_helper'
 
 describe 'Record SQL queries in a Rails4 app' do
-  before(:all) { @fixture_dir = 'spec/fixtures/rails4_users_app' }
-  include_context 'Rails app pg database'
-  
-  around(:each) do |example|
-    FileUtils.rm_rf tmpdir
-    FileUtils.mkdir_p tmpdir
-    cmd = "docker-compose run --rm -e ORM_MODULE=#{orm_module} -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:#{test_line_number}"
-    run_cmd cmd, chdir: @fixture_dir
+  include_context 'Rails app pg database', 'spec/fixtures/rails4_users_app' do
+    around(:each) do |example|
+      FileUtils.rm_rf tmpdir
+      FileUtils.mkdir_p tmpdir
+      cmd = "docker-compose run --rm -e ORM_MODULE=#{orm_module} -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:#{test_line_number}"
+      run_cmd cmd, chdir: fixture_dir
 
-    example.run
-  end
+      example.run
+    end
+
+    let(:tmpdir) { "tmp/spec/record_sql_rails_pg_spec" }
+    let(:appmap) { JSON.parse(File.read(appmap_json)).to_yaml }
 
-  let(:tmpdir) { "tmp/spec/record_sql_rails_pg_spec" }
-  let(:appmap) { JSON.parse(File.read(appmap_json)).to_yaml }
+    context 'when running specs' do
+      let(:test_line_number) { 31 }
+      let(:orm_module) { 'activerecord' }
 
-  context 'when running specs' do
-    let(:test_line_number) { 31 }
-    let(:orm_module) { 'activerecord' }
+      it { is_expected.to be }
+    end
 
-    it { is_expected.to be }
-  end
-  
-  context 'while creating a new record' do
-    let(:test_line_number) { 8 }
-    let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
+    context 'while creating a new record' do
+      let(:test_line_number) { 8 }
+      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
 
-    xcontext 'using Sequel ORM' do
-      let(:orm_module) { 'sequel' }
-      it 'detects the sql INSERT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+      xcontext 'using Sequel ORM' do
+        let(:orm_module) { 'sequel' }
+        it 'detects the sql INSERT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: INSERT INTO "users" ("login") VALUES ('alice') RETURNING *
-        SQL_QUERY
+          SQL_QUERY
+        end
       end
-    end
-    context 'using ActiveRecord ORM' do
-      let(:orm_module) { 'activerecord' }
-      it 'detects the sql INSERT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+      context 'using ActiveRecord ORM' do
+        let(:orm_module) { 'activerecord' }
+        it 'detects the sql INSERT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: INSERT INTO "users" ("login", "created_at", "updated_at") VALUES ($1, $2,
       $3) RETURNING "id"
-        SQL_QUERY
+          SQL_QUERY
+        end
       end
     end
-  end
 
-  context 'while listing records' do
-    let(:test_line_number) { 23 }
-    let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
+    context 'while listing records' do
+      let(:test_line_number) { 23 }
+      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
 
-    xcontext 'using Sequel ORM' do
-      let(:orm_module) { 'sequel' }
-      it 'detects the sql SELECT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+      xcontext 'using Sequel ORM' do
+        let(:orm_module) { 'sequel' }
+        it 'detects the sql SELECT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: SELECT * FROM "users"
-        SQL_QUERY
+          SQL_QUERY
 
-        expect(appmap).to include('sql:')
+          expect(appmap).to include('sql:')
+        end
       end
-    end
-    context 'using ActiveRecord ORM' do
-      let(:orm_module) { 'activerecord' }
-      it 'detects the sql SELECT' do
-        expect(appmap).to include(<<-SQL_QUERY.strip)
+      context 'using ActiveRecord ORM' do
+        let(:orm_module) { 'activerecord' }
+        it 'detects the sql SELECT' do
+          expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: SELECT "users".* FROM "users"
-        SQL_QUERY
+          SQL_QUERY
+        end
       end
     end
   end

data/spec/record_sql_rails_pg_spec.rb

@@ -1,89 +1,88 @@
 require 'rails_spec_helper'
 
 describe 'SQL events' do
-  before(:all) { @fixture_dir = 'spec/fixtures/rails_users_app' }
-  include_context 'Rails app pg database'
+  include_context 'Rails app pg database', 'spec/fixtures/rails5_users_app' do
+    around(:each) do |example|
+      FileUtils.rm_rf tmpdir
+      FileUtils.mkdir_p tmpdir
+      cmd = "docker-compose run --rm -e ORM_MODULE=#{orm_module} -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:#{test_line_number}"
+      run_cmd cmd, chdir: fixture_dir
 
-  around(:each) do |example|
-    FileUtils.rm_rf tmpdir
-    FileUtils.mkdir_p tmpdir
-    cmd = "docker-compose run --rm -e ORM_MODULE=#{orm_module} -e APPMAP=true -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec spec/controllers/users_controller_api_spec.rb:#{test_line_number}"
-    run_cmd cmd, chdir: @fixture_dir
-
-    example.run
-  end
+      example.run
+    end
 
-  let(:tmpdir) { "tmp/spec/record_sql_rails_pg_spec" }
+    let(:tmpdir) { "tmp/spec/record_sql_rails_pg_spec" }
 
-  describe 'fields' do
-    let(:test_line_number) { 8 }
-    let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
-    let(:orm_module) { 'sequel' }
-    let(:appmap) { JSON.parse(File.read(appmap_json)) }
-    describe 'on a call event' do
-      let(:event) do
-        appmap['events'].find do |event|
-          event['event'] == 'call' &&
-            event.keys.include?('sql_query')
+    describe 'fields' do
+      let(:test_line_number) { 8 }
+      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
+      let(:orm_module) { 'sequel' }
+      let(:appmap) { JSON.parse(File.read(appmap_json)) }
+      describe 'on a call event' do
+        let(:event) do
+          appmap['events'].find do |event|
+            event['event'] == 'call' &&
+              event.keys.include?('sql_query')
+          end
+        end
+        it 'do not include function-only fields' do
+          expect(event.keys).to_not include('defined_class')
+          expect(event.keys).to_not include('method_id')
+          expect(event.keys).to_not include('path')
+          expect(event.keys).to_not include('lineno')
         end
-      end
-      it 'do not include function-only fields' do
-        expect(event.keys).to_not include('defined_class')
-        expect(event.keys).to_not include('method_id')
-        expect(event.keys).to_not include('path')
-        expect(event.keys).to_not include('lineno')
       end
     end
-  end
 
-  describe 'in a Rails app' do
-    let(:appmap) { JSON.parse(File.read(appmap_json)).to_yaml }
-    context 'while creating a new record' do
-      let(:test_line_number) { 8 }
-      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
+    describe 'in a Rails app' do
+      let(:appmap) { JSON.parse(File.read(appmap_json)).to_yaml }
+      context 'while creating a new record' do
+        let(:test_line_number) { 8 }
+        let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_POST_api_users_with_required_parameters_creates_a_user.appmap.json') }
 
-      context 'using Sequel ORM' do
-        let(:orm_module) { 'sequel' }
-        it 'detects the sql INSERT' do
-          expect(appmap).to include(<<-SQL_QUERY.strip)
+        context 'using Sequel ORM' do
+          let(:orm_module) { 'sequel' }
+          it 'detects the sql INSERT' do
+            expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: INSERT INTO "users" ("login") VALUES ('alice') RETURNING *
-          SQL_QUERY
+            SQL_QUERY
+          end
         end
-      end
-      context 'using ActiveRecord ORM' do
-        let(:orm_module) { 'activerecord' }
-        it 'detects the sql INSERT' do
-          expect(appmap).to include(<<-SQL_QUERY.strip)
+        context 'using ActiveRecord ORM' do
+          let(:orm_module) { 'activerecord' }
+          it 'detects the sql INSERT' do
+            expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: INSERT INTO "users" ("login") VALUES ($1) RETURNING "id"
-          SQL_QUERY
+            SQL_QUERY
+          end
         end
       end
-    end
-  
-    context 'while listing records' do
-      let(:test_line_number) { 23 }
-      let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
-  
-      context 'using Sequel ORM' do
-        let(:orm_module) { 'sequel' }
-        it 'detects the sql SELECT' do
-          expect(appmap).to include(<<-SQL_QUERY.strip)
+
+      context 'while listing records' do
+        let(:test_line_number) { 23 }
+        let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
+
+        context 'using Sequel ORM' do
+          let(:orm_module) { 'sequel' }
+          it 'detects the sql SELECT' do
+            expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: SELECT * FROM "users"
-          SQL_QUERY
-  
-          expect(appmap).to include('sql:')
+            SQL_QUERY
+ 
+            expect(appmap).to include('sql:')
+          end
         end
-      end
-      context 'using ActiveRecord ORM' do
-        let(:orm_module) { 'activerecord' }
-        it 'detects the sql SELECT' do
-          expect(appmap).to include(<<-SQL_QUERY.strip)
+        context 'using ActiveRecord ORM' do
+          let(:orm_module) { 'activerecord' }
+          it 'detects the sql SELECT' do
+            expect(appmap).to include(<<-SQL_QUERY.strip)
   sql_query:
     sql: SELECT "users".* FROM "users"
-          SQL_QUERY
+            SQL_QUERY
+          end
         end
       end
     end

data/spec/remote_recording_spec.rb

@@ -3,115 +3,116 @@ require 'net/http'
 require 'socket'
 
 describe 'remote recording', :order => :defined do
-  before(:all) { @fixture_dir = 'spec/fixtures/rails_users_app' }
-  include_context 'Rails app pg database'
-
-  before(:all) do
-    start_cmd = 'docker-compose up -d app'
-    run_cmd({ 'ORM_MODULE' => 'sequel', 'APPMAP' => 'true' }, start_cmd, chdir: @fixture_dir)
-    Dir.chdir @fixture_dir do
-      wait_for_container 'app'
-    end
-
-    port_cmd = 'docker-compose port app 3000'
-    port_out, = run_cmd port_cmd, chdir: @fixture_dir
-    @service_port = port_out.strip.split(':')[1]
-
-    service_running = false
-    retry_count = 0
-    uri = URI("http://localhost:#{@service_port}/health")
+  include_context 'Rails app pg database', 'spec/fixtures/rails5_users_app' do
+    before(:all) do
+      fixture_dir = 'spec/fixtures/rails5_users_app'
+      start_cmd = 'docker-compose up -d app'
+      run_cmd({ 'ORM_MODULE' => 'sequel', 'APPMAP' => 'true' }, start_cmd, chdir: fixture_dir)
+      Dir.chdir fixture_dir do
+        wait_for_container 'app'
+      end
 
-    until service_running
-      sleep(0.25)
-      begin
-        res = Net::HTTP.start(uri.hostname, uri.port) do |http|
-          http.request(Net::HTTP::Get.new(uri))
+      port_cmd = 'docker-compose port app 3000'
+      port_out, = run_cmd port_cmd, chdir: fixture_dir
+      @service_port = port_out.strip.split(':')[1]
+
+      service_running = false
+      retry_count = 0
+      uri = URI("http://localhost:#{@service_port}/health")
+
+      until service_running
+        sleep(0.25)
+        begin
+          res = Net::HTTP.start(uri.hostname, uri.port) do |http|
+            http.request(Net::HTTP::Get.new(uri))
+          end
+
+          status = res.response.code.to_i
+          service_running = true if status >= 200 && status < 300
+
+          # give up after a certain error threshold is met
+          # we don't want to wait forever if there's an unrecoverable issue
+          raise 'gave up waiting on fixture service' if (retry_count += 1) == 10
+        rescue Errno::ETIMEDOUT, Errno::ECONNRESET, EOFError
+          $stderr.print('.')
         end
-
-        status = res.response.code.to_i
-        service_running = true if status >= 200 && status < 300
-
-        # give up after a certain error threshold is met
-        # we don't want to wait forever if there's an unrecoverable issue
-        raise 'gave up waiting on fixture service' if (retry_count += 1) == 10
-      rescue Errno::ETIMEDOUT, Errno::ECONNRESET, EOFError
-        $stderr.print('.')
       end
     end
-  end
 
-  def json_body(res)
-    JSON.parse(res.body).deep_symbolize_keys
-  end
+    def json_body(res)
+      JSON.parse(res.body).deep_symbolize_keys
+    end
 
-  after(:all) do
-    run_cmd 'docker-compose rm -fs app', chdir: @fixture_dir
-  end
+    after(:all) do
+      fixture_dir = 'spec/fixtures/rails5_users_app'
+      run_cmd 'docker-compose rm -fs app', chdir: fixture_dir
+    end
 
-  let(:service_address) { URI("http://localhost:#{@service_port}") }
-  let(:users_path) { '/users' }
-  let(:record_path) { '/_appmap/record' }
+    let(:service_address) { URI("http://localhost:#{@service_port}") }
+    let(:users_path) { '/users' }
+    let(:record_path) { '/_appmap/record' }
 
-  it 'returns the recording status' do
-    res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
-      http.request(Net::HTTP::Get.new(record_path))
-    }
+    it 'returns the recording status' do
+      res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
+        http.request(Net::HTTP::Get.new(record_path))
+      }
 
-    expect(res).to be_a(Net::HTTPOK)
-    expect(res['Content-Type']).to eq('application/json')
-    expect(json_body(res)).to eq(enabled: false)
-  end
+      expect(res).to be_a(Net::HTTPOK)
+      expect(res['Content-Type']).to eq('application/json')
+      expect(json_body(res)).to eq(enabled: false)
+    end
 
-  it 'starts a new recording session' do
-    res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
-      http.request(Net::HTTP::Post.new(record_path))
-    }
+    it 'starts a new recording session' do
+      res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
+        http.request(Net::HTTP::Post.new(record_path))
+      }
 
-    expect(res).to be_a(Net::HTTPOK)
-  end
+      expect(res).to be_a(Net::HTTPOK)
+    end
 
-  it 'reflects the recording status' do
-    res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
-      http.request(Net::HTTP::Get.new(record_path))
-    }
+    it 'reflects the recording status' do
+      res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
+        http.request(Net::HTTP::Get.new(record_path))
+      }
 
-    expect(res).to be_a(Net::HTTPOK)
-    expect(res['Content-Type']).to eq('application/json')
-    expect(json_body(res)).to eq(enabled: true)
-  end
+      expect(res).to be_a(Net::HTTPOK)
+      expect(res['Content-Type']).to eq('application/json')
+      expect(json_body(res)).to eq(enabled: true)
+    end
 
-  it 'fails to start a new recording session while recording is already active' do
-    res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
-      http.request(Net::HTTP::Post.new(record_path))
-    }
+    it 'fails to start a new recording session while recording is already active' do
+      res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
+        http.request(Net::HTTP::Post.new(record_path))
+      }
 
-    expect(res).to be_a(Net::HTTPConflict)
-  end
+      expect(res).to be_a(Net::HTTPConflict)
+    end
 
-  it 'stops recording' do
-    # Generate some events
-    Net::HTTP.start(service_address.hostname, service_address.port) { |http|
-      http.request(Net::HTTP::Get.new(users_path) )
-    }
+    it 'stops recording' do
+      # Generate some events
+      Net::HTTP.start(service_address.hostname, service_address.port) { |http|
+        http.request(Net::HTTP::Get.new(users_path) )
+      }
 
-    res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
-      http.request(Net::HTTP::Delete.new(record_path))
-    }
+      res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
+        http.request(Net::HTTP::Delete.new(record_path))
+      }
 
-    expect(res).to be_a(Net::HTTPOK)
-    expect(res['Content-Type']).to eq('application/json')
+      expect(res).to be_a(Net::HTTPOK)
+      expect(res['Content-Type']).to eq('application/json')
 
-    data = json_body(res)
-    expect(data[:metadata]).to be_truthy
-    expect(data[:classMap].length).to be > 0
-    expect(data[:events].length).to be > 0
-  end
+      data = json_body(res)
+      expect(data[:metadata]).to be_truthy
+      expect(data[:classMap].length).to be > 0
+      expect(data[:events].length).to be > 0
+    end
 
-  it 'fails to stop recording if there is no active recording session' do
-    res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
-      http.request(Net::HTTP::Delete.new(record_path))
-    }
+    it 'fails to stop recording if there is no active recording session' do
+      res = Net::HTTP.start(service_address.hostname, service_address.port) { |http|
+        http.request(Net::HTTP::Delete.new(record_path))
+      }
 
-    expect(res).to be_a(Net::HTTPNotFound)
+      expect(res).to be_a(Net::HTTPNotFound)
+    end
   end
 end