appmap 0.31.0

data/spec/rails_spec_helper.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'open3'
+
+def wait_for_container(app_name)
+  start_time = Time.now
+  until `docker-compose ps -q --filter health=healthy #{app_name}`.strip != ''
+    elapsed = Time.now - start_time
+    raise "Timeout waiting for container #{app_name} to be ready" if elapsed > 10
+
+    $stderr.write '.' if elapsed > 3
+    sleep 0.25
+  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
+
+shared_context 'Rails app pg database' do
+  before(:all) do
+    raise 'you must set @fixure_dir' unless @fixture_dir
+
+    print_pg_logs = lambda do
+      logs, = run_cmd 'docker-compose logs pg'
+      puts "docker-compose logs for pg:"
+      puts
+      puts logs
+    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'
+
+      cmd = 'docker-compose run --rm app ./create_app'
+      run_cmd cmd, &print_pg_logs
+    end
+  end
+
+  after(:all) do
+    if ENV['NOKILL'] != 'true'
+      cmd = 'docker-compose down -v'
+      run_cmd cmd, chdir: @fixture_dir
+    end
+  end
+end

data/spec/railtie_spec.rb

@@ -0,0 +1,44 @@
+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) { {} }
+
+  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'
+      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
+
+  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

@@ -0,0 +1,76 @@
+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
+
+    example.run
+  end
+
+  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' }
+
+    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') }
+
+    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
+      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", "created_at", "updated_at") VALUES ($1, $2,
+      $3) RETURNING "id"
+        SQL_QUERY
+      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') }
+
+    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
+
+        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
+end

data/spec/record_sql_rails_pg_spec.rb

@@ -0,0 +1,68 @@
+require 'rails_spec_helper'
+
+describe 'Record SQL queries in a Rails app' do
+  before(:all) { @fixture_dir = 'spec/fixtures/rails_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
+
+    example.run
+  end
+
+  let(:tmpdir) { "tmp/spec/record_sql_rails_pg_spec" }
+  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)
+  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
+
+  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:')
+      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
+end

data/spec/remote_recording_spec.rb

@@ -0,0 +1,117 @@
+require 'rails_spec_helper'
+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")
+
+    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
+    end
+  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
+
+  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))
+    }
+
+    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))
+    }
+
+    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))
+    }
+
+    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))
+    }
+
+    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) )
+    }
+
+    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')
+
+    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))
+    }
+
+    expect(res).to be_a(Net::HTTPNotFound)
+  end
+end

data/spec/rspec_feature_metadata_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails_spec_helper'
+
+describe 'RSpec feature and feature group metadata' do
+  before(:all) { @fixture_dir = 'spec/fixtures/rails_users_app' }
+  include_examples 'Rails app pg database'
+  
+  around(:each) do |example|
+    FileUtils.rm_rf tmpdir
+    FileUtils.mkdir_p tmpdir
+    cmd = "docker-compose run --rm -e APPMAP=true -v #{File.absolute_path(tmpdir).shellescape}:/app/tmp app ./bin/rspec spec/models/user_spec.rb"
+    run_cmd cmd, chdir: @fixture_dir
+
+    example.run
+  end
+
+  let(:tmpdir) { 'tmp/spec/RSpec feature and feature group metadata' }
+  let(:appmap_json) { File.join(tmpdir, %(appmap/rspec/User_creation_creates_charles.appmap.json)) }
+
+  describe do
+    it 'are recorded in the appmap' do
+      expect(File).to exist(appmap_json)
+      appmap = JSON.parse(File.read(appmap_json)).to_yaml
+
+      expect(appmap).to include(<<-METADATA.strip)
+  feature: Create a user
+  feature_group: User
+      METADATA
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'rspec'
+require 'net/http'
+require 'json'
+require 'yaml'
+require 'English'
+require 'webdrivers/chromedriver'
+
+# Disable default initialization of AppMap
+ENV['APPMAP_INITIALIZE'] = 'false'
+
+require 'appmap'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = "tmp/rspec_failed_examples.txt"
+end

data/spec/util_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'appmap/util'
+
+describe AppMap::Util, docker: false do
+  let(:subject) { AppMap::Util.method(:scenario_filename) }
+  describe 'scenario_filename' do
+    it 'leaves short names alone' do
+      expect(subject.call('foobar')).to eq('foobar.appmap.json')
+    end
+    it 'has a customizable suffix' do
+      expect(subject.call('foobar', extension: '.json')).to eq('foobar.json')
+    end
+    it 'limits the filename length' do
+      fname = (0...104).map { |i| ((i % 26) + 97).chr }.join
+
+      expect(subject.call(fname, max_length: 50)).to eq('abcdefghijklmno-RAd_SFbH1sUZ_OXfwPsfzw.appmap.json')
+    end
+  end
+end

data/test/cli_test.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'English'
+
+class CLITest < Minitest::Test
+  OUTPUT_FILENAME = File.expand_path('../tmp/appmap.json', __dir__)
+  STATS_OUTPUT_FILENAME = File.expand_path('../tmp/stats.txt', __dir__)
+
+  def setup
+    FileUtils.rm_f OUTPUT_FILENAME
+    FileUtils.rm_f STATS_OUTPUT_FILENAME
+  end
+
+  def test_record
+    output = Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
+    end
+
+    assert_equal 0, $CHILD_STATUS.exitstatus
+    assert File.file?(OUTPUT_FILENAME), "#{OUTPUT_FILENAME} does not exist"
+    assert_equal 'Hello', output
+    output = JSON.parse(File.read(OUTPUT_FILENAME))
+    assert output['classMap'], 'Output should contain classMap'
+    assert output['events'], 'Output should contain events'
+  end
+
+  def test_stats_to_file
+    Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
+    end
+    assert_equal 0, $CHILD_STATUS.exitstatus
+
+    output = Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} stats -o #{STATS_OUTPUT_FILENAME} #{OUTPUT_FILENAME}`.strip
+    end
+    assert_equal 0, $CHILD_STATUS.exitstatus
+    assert_equal '', output
+    assert File.file?(OUTPUT_FILENAME), "#{OUTPUT_FILENAME} does not exist"
+  end
+
+
+  def test_stats_text
+    Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
+    end
+    assert_equal 0, $CHILD_STATUS.exitstatus
+
+    output = Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} stats -o - #{OUTPUT_FILENAME}`.strip
+    end
+
+    assert_equal 0, $CHILD_STATUS.exitstatus
+    assert_equal <<~OUTPUT.strip, output.strip
+    Class frequency:
+    ----------------
+    2	Main
+
+    Method frequency:
+    ----------------
+    1	Main.say_hello
+    OUTPUT
+  end
+
+  def test_stats_json
+    Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} record -o #{OUTPUT_FILENAME} ./lib/cli_record_test/main.rb`.strip
+    end
+    assert_equal 0, $CHILD_STATUS.exitstatus
+
+    output = Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} stats -f json -o - #{OUTPUT_FILENAME}`.strip
+    end
+
+    assert_equal 0, $CHILD_STATUS.exitstatus
+    assert_equal <<~OUTPUT.strip, output.strip
+    {
+      "class_frequency": [
+        {
+          "name": "Main",
+          "count": 2
+        }
+      ],
+      "method_frequency": [
+        {
+          "name": "Main.say_hello",
+          "count": 1
+        }
+      ]
+    }
+    OUTPUT
+  end
+
+  def test_record_to_default_location
+    Dir.chdir 'test/fixtures/cli_record_test' do
+      system({ 'APPMAP_FILE' => OUTPUT_FILENAME }, "#{File.expand_path '../exe/appmap', __dir__} record ./lib/cli_record_test/main.rb")
+    end
+
+    assert_equal 0, $CHILD_STATUS.exitstatus
+    assert File.file?(OUTPUT_FILENAME), 'appmap.json does not exist'
+  end
+
+  def test_record_to_stdout
+    output = Dir.chdir 'test/fixtures/cli_record_test' do
+      `#{File.expand_path '../exe/appmap', __dir__} record -o - ./lib/cli_record_test/main.rb`
+    end
+
+    assert_equal 0, $CHILD_STATUS.exitstatus
+    # Event path
+    assert_includes output, %("path":"lib/cli_record_test/main.rb")
+    # Function location
+    assert_includes output, %("location":"lib/cli_record_test/main.rb:3")
+    assert !File.file?(OUTPUT_FILENAME), "#{OUTPUT_FILENAME} should not exist"
+  end
+end