appmap 0.77.4 → 0.80.0

data/spec/rails_spec_helper.rb

@@ -1,93 +1,106 @@
 # frozen_string_literal: true
 
+require 'open3'
+
 require 'spec_helper'
 require 'active_support'
 require 'active_support/core_ext'
-require 'open3'
 
-# The RUBY_VERSION global variable indicates the version of the
-# runtime. The RUBY_VERSION environment variable is the version we're
-# testing, so it needs to be used to pick a fixture directory.
 def testing_ruby_2?
-  ENV['RUBY_VERSION'].split('.')[0].to_i == 2
+  RUBY_VERSION.split('.')[0].to_i == 2
 end
 
-# docker compose v2 replaced the --filter flag with --status
-PS_CMD=`docker-compose --version` =~ /version v2/ ?
-         "docker-compose ps -q --status running" :
-         "docker-compose ps -q --filter health=healthy"
+class TestRailsApp
+  def initialize(fixture_dir)
+    @fixture_dir = fixture_dir
+  end
 
-def wait_for_container(app_name)
-  start_time = Time.now
-  until `#{PS_CMD} #{app_name}`.strip != ''
-    elapsed = Time.now - start_time
-    raise "Timeout waiting for container #{app_name} to be ready" if elapsed > 10
+  attr_reader :fixture_dir
 
-    $stderr.write '.' if elapsed > 3
-    sleep 0.25
+  def run_cmd(cmd, env = {})
+    run_process method(:system), cmd, env, exception: true
   end
-end
 
-def run_cmd(*cmd, &failed)
-  out, status = Open3.capture2e(*cmd)
-  return [ out, status ] if status.success?
-
-  warn <<~WARNING
-    Command failed:
-    #{cmd}
-    <<< Output:
-    #{out}
-    >>> End of output
-  WARNING
-  failed&.call
-  raise 'Command failed'
-end
+  def spawn_cmd(cmd, env = {})
+    puts "Spawning `#{cmd}` in #{fixture_dir}..."
+    run_process Process.method(:spawn), cmd, env
+  end
 
-shared_context 'Rails app pg database' do |fixture_dir|
-  define_method(:fixture_dir) { fixture_dir }
+  def capture_cmd(cmd, env = {})
+    puts "Capturing `#{cmd}` in #{fixture_dir}..."
+    run_process(Open3.method(:capture2), cmd, env).first
+  end
 
-  before(:all) do
-    print_pg_logs = lambda do
-      logs, = run_cmd 'docker-compose logs pg'
-      puts "docker-compose logs for pg:"
-      puts
-      puts logs
-    end
+  def database_name
+    # This is used locally too, so make the name nice and unique.
+    @database_name ||= "appland-rails-test-#{Random.bytes(8).unpack1('h*')}"
+  end
 
-    Dir.chdir fixture_dir do
-      run_cmd 'docker-compose down -v'
-      cmd = 'docker-compose up -d pg'
-      run_cmd cmd
-      wait_for_container 'pg'
+  def bundle
+    return if @bundled
 
-      cmd = 'docker-compose run --rm app ./create_app'
-      run_cmd cmd, &print_pg_logs
-    end
+    run_cmd 'bundle'
+    @bundled = true
   end
 
-  after(:all) do
-    if ENV['NOKILL'] != 'true'
-      cmd = 'docker-compose down -v'
-      run_cmd cmd, chdir: fixture_dir
-    end
+  def prepare_db
+    return if @db_prepared
+
+    bundle
+    run_cmd './bin/rake db:create db:schema:load'
+    @db_prepared = true
+    at_exit { drop_db }
+  end
+
+  def drop_db
+    return unless @db_prepared
+
+    run_cmd './bin/rake db:drop'
+    @db_prepared = false
   end
-end
 
-shared_context 'rails integration test setup' do
   def tmpdir
-    'tmp/spec/AbstractControllerBase'
+    @tmpdir ||= File.join(fixture_dir, 'tmp')
+  end
+
+  def run_specs
+    return if @specs_ran or use_existing_data?
+
+    prepare_db
+    FileUtils.rm_rf tmpdir
+    run_cmd \
+      './bin/rspec spec/controllers/users_controller_spec.rb spec/controllers/users_controller_api_spec.rb',
+      'APPMAP' => 'true'
+    @specs_ran = true
+  end
+
+  def self.for_fixture(fixture_dir)
+    @apps ||= {}
+    @apps[fixture_dir] ||= TestRailsApp.new fixture_dir
   end
 
-  unless use_existing_data?
-    before(:all) do
-      FileUtils.rm_rf tmpdir
-      FileUtils.mkdir_p tmpdir
-      run_spec 'spec/controllers/users_controller_spec.rb'
-      run_spec 'spec/controllers/users_controller_api_spec.rb'
+  protected
+
+  def run_process(method, cmd, env, options = {})
+    Bundler.with_clean_env do
+      method.call \
+        env.merge('TEST_DATABASE' => database_name),
+        cmd,
+        options.merge(chdir: fixture_dir)
     end
   end
+end
+
+shared_context 'Rails app pg database' do |dir|
+  before(:all) { @app = TestRailsApp.for_fixture dir }
+  let(:app) { @app }
+end
+
+shared_context 'rails integration test setup' do
+  let(:tmpdir) { app.tmpdir }
+
+  before(:all) { @app.run_specs } unless use_existing_data?
 
-  let(:appmap) { JSON.parse File.read File.join tmpdir, 'appmap/rspec', appmap_json_file }
   let(:appmap_json_path) { File.join(tmpdir, 'appmap/rspec', appmap_json_file) }
   let(:appmap) { JSON.parse File.read(appmap_json_path) }
   let(:events) { appmap['events'] }

data/spec/rails_test_spec.rb

@@ -3,7 +3,7 @@ require 'rails_spec_helper'
 # Rails5 doesn't work with Ruby 3.x, Rails 7 doesn't work with Ruby < 2.7.
 def default_rails_versions
   if testing_ruby_2?
-    if Gem::Requirement.create('>= 2.7') =~ Gem::Version.new(ENV['RUBY_VERSION'])
+    if Gem::Requirement.create('>= 2.7') =~ Gem::Version.new(RUBY_VERSION)
       [ 5, 6, 7 ]
     else
       [ 5, 6 ]
@@ -21,24 +21,14 @@ describe 'Rails' do
   rails_versions.each do |rails_major_version| # rubocop:disable Metrics/BlockLength
     context "#{rails_major_version}" do
       include_context 'Rails app pg database', "spec/fixtures/rails#{rails_major_version}_users_app" unless use_existing_data?
-      def tmpdir
-        'tmp/spec/rails_test_spec'
-      end
-      before(:all) do
-        FileUtils.rm_rf tmpdir
-        FileUtils.mkdir_p tmpdir
-      end
-
-      def run_tests
-        cmd = <<~CMD.gsub "\n", ' '
-          docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true -e TEST_OPTS=--verbose
-          -v #{File.absolute_path tmpdir}:/app/tmp app bundle exec rake
-        CMD
-        run_cmd cmd, chdir: fixture_dir
-      end
 
       it 'runs tests with APPMAP=true' do
-        run_tests
+        app.prepare_db
+        app.run_cmd \
+          'bundle exec rake',
+          'RAILS_ENV' => 'test',
+          'APPMAP' => 'true',
+          'TEST_OPTS' => '--verbose'
       end
     end
   end

data/spec/railtie_spec.rb

@@ -1,27 +1,13 @@
 require 'rails_spec_helper'
 
 describe 'AppMap tracer via Railtie' do
-  include_context 'Rails app pg database', 'spec/fixtures/rails6_users_app' do 
+  include_context 'Rails app pg database', 'spec/fixtures/rails6_users_app' do
     let(:env) { {} }
 
-    let(:cmd) { %(docker-compose run --rm -e RAILS_ENV=development -e APPMAP app ./bin/rails r "puts AppMap.instance_variable_get('@configuration').nil?") }
-    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 rails6_users_app container
-            <<< Output:
-            #{result[0]}
-            #{result[1]}
-            >>> End of output
-          STDERR
-          raise 'Failed to run rails6_users_app container'
-        end
-      end
+    let(:command_output) do
+      app.prepare_db
+      app.capture_cmd(%{./bin/rails r "puts AppMap.instance_variable_get('@configuration').nil?"}, env).strip
     end
-    let(:command_output) { command_capture2[0].strip }
-    let(:command_result) { command_capture2[2] }
 
     describe 'with APPMAP=false' do
       let(:env) { { 'APPMAP' => 'false' } }

data/spec/record_sql_rails_pg_spec.rb

@@ -2,89 +2,58 @@ require 'rails_spec_helper'
 
 describe 'SQL events' do
   include_context 'Rails app pg database', 'spec/fixtures/rails6_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 RAILS_ENV=test -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
-
-    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')
+    def self.check_queries(cases)
+      cases.each do |test_case, query|
+        context "in #{test_case}" do
+          let(:test_case) { test_case }
+          it "captures #{query}" do
+            expect(sql_events).to include sql_query 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
     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') }
+    context 'with Sequel' do
+      before(:context) { run_specs 'sequel' }
 
-        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
-          end
-        end
-        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
-          end
-        end
-      end
+      check_queries(
+        'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user' =>
+          %(INSERT INTO "users" ("login") VALUES ('alice') RETURNING *),
+        'Api_UsersController_GET_api_users_lists_the_users' => %(SELECT * FROM "users")
+      )
+    end
 
-      context 'while listing records' do
-        let(:test_line_number) { 29 }
-        let(:appmap_json) { File.join(tmpdir, 'appmap/rspec/Api_UsersController_GET_api_users_lists_the_users.appmap.json') }
+    context 'with ActiveRecord' do
+      before(:context) { run_specs 'activerecord' }
 
-        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:')
-          end
-        end
-        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
-          end
-        end
-      end
+      check_queries(
+        'Api_UsersController_POST_api_users_with_required_parameters_creates_a_user' =>
+          %(INSERT INTO "users" ("login") VALUES ($1) RETURNING "id"),
+        'Api_UsersController_GET_api_users_lists_the_users' => %(SELECT "users".* FROM "users")
+      )
+    end
+
+    def run_specs(orm_module)
+      @app.prepare_db
+      @app.run_cmd \
+        './bin/rspec spec/controllers/users_controller_api_spec.rb:8 spec/controllers/users_controller_api_spec.rb:29',
+        'ORM_MODULE' => orm_module,
+        'RAILS_ENV' => 'test',
+        'APPMAP' => 'true'
+    end
+
+    let(:appmap_json) { File.join tmpdir, "appmap/rspec/#{test_case}.appmap.json" }
+    let(:appmap) { JSON.parse(File.read(appmap_json)) }
+    let(:tmpdir) { app.tmpdir }
+    let(:sql_events) { appmap['events'].select { |ev| ev.include? 'sql_query' } }
+
+    RSpec::Matchers.define_negated_matcher :not_include, :include
+    def sql_query(query)
+      (include('sql_query' => (include 'sql' => query)))
+        .and(not_include('defined_class'))
+        .and(not_include('method_id'))
+        .and(not_include('path'))
+        .and(not_include('lineno'))
     end
   end
 end

data/spec/remote_recording_spec.rb

@@ -1,41 +1,27 @@
 require 'rails_spec_helper'
+
+require 'random-port'
+
 require 'net/http'
 require 'socket'
 
 describe 'remote recording', :order => :defined do
   include_context 'Rails app pg database', 'spec/fixtures/rails6_users_app' do
     before(:all) do
-      fixture_dir = 'spec/fixtures/rails6_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
+      @service_port = RandomPort::Pool::SINGLETON.acquire
+      @app.prepare_db
+      @server = @app.spawn_cmd \
+        "./bin/rails server -p #{@service_port}",
+        'ORM_MODULE' => 'sequel',
+        'APPMAP' => 'true'
 
-      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
+      100.times do
+        Net::HTTP.get(uri)
+        break
+      rescue Errno::ECONNREFUSED
+        sleep 0.1
       end
     end
 
@@ -44,8 +30,10 @@ describe 'remote recording', :order => :defined do
     end
 
     after(:all) do
-      fixture_dir = 'spec/fixtures/rails6_users_app'
-      run_cmd 'docker-compose rm -fs app', chdir: fixture_dir
+      if @server
+        Process.kill 'INT', @server
+        Process.wait @server
+      end
     end
 
     let(:service_address) { URI("http://localhost:#{@service_port}") }

data/spec/spec_helper.rb

@@ -13,6 +13,7 @@ require 'appmap'
 
 RSpec.configure do |config|
   config.example_status_persistence_file_path = "tmp/rspec_failed_examples.txt"
+  config.profile_examples = true
 end
 
 # Re-run the Rails specs without re-generating the data. This is useful for efficiently enhancing and

data/spec/swagger/swagger_spec.rb

@@ -4,24 +4,9 @@ describe 'rake appmap:swagger' do
   include_context 'Rails app pg database', "spec/fixtures/rails6_users_app" unless use_existing_data?
   include_context 'rails integration test setup'
 
-  def run_spec(spec_name)
-    cmd = <<~CMD.gsub "\n", ' '
-      docker-compose run --rm -e RAILS_ENV=test -e APPMAP=true
-      -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rspec #{spec_name}
-    CMD
-    run_cmd cmd, chdir: fixture_dir
-  end
-
-  def generate_swagger
-    cmd = <<~CMD.gsub "\n", ' '
-      docker-compose run --rm -v #{File.absolute_path tmpdir}:/app/tmp app ./bin/rake appmap:swagger
-    CMD
-    run_cmd cmd, chdir: fixture_dir
-  end
-
   unless use_existing_data?
     before(:all) do
-      generate_swagger
+      @app.run_cmd './bin/rake appmap:swagger'
     end
   end
 

data/spec/util_spec.rb

@@ -3,7 +3,7 @@
 require 'spec_helper'
 require 'appmap/util'
 
-describe AppMap::Util, docker: false do
+describe AppMap::Util do
   describe 'scenario_filename' do
     let(:subject) { AppMap::Util.method(:scenario_filename) }
     it 'leaves short names alone' do

data/test/expectations/openssl_test_key_sign2-3.1.json

@@ -26,7 +26,8 @@
         "name": "arg",
         "class": "Array",
         "value": "[e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855, the document]",
-        "kind": "rest"
+        "kind": "rest",
+        "size": 2
       }
     ],
     "receiver": {