appmap 0.83.4 → 0.83.5

data/spec/remote_recording_spec.rb

@@ -1,108 +0,0 @@
-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
-      @service_port = RandomPort::Pool::SINGLETON.acquire
-      @app.prepare_db
-      @server = @app.spawn_cmd \
-        "./bin/rails server -p #{@service_port}",
-        'ORM_MODULE' => 'sequel',
-        'APPMAP' => 'true'
-
-      uri = URI("http://localhost:#{@service_port}/health")
-
-      100.times do
-        begin
-          Net::HTTP.get(uri)
-          break
-        rescue Errno::ECONNREFUSED
-          sleep 0.1
-        end
-      end
-    end
-
-    def json_body(res)
-      JSON.parse(res.body).deep_symbolize_keys
-    end
-
-    after(:all) do
-      if @server
-        Process.kill 'INT', @server
-        Process.wait @server
-      end
-    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
-end

data/spec/service/config_analyzer_spec.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'appmap/service/config_analyzer'
-
-describe AppMap::Service::ConfigAnalyzer do
-  subject { described_class.new(config_file) }
-
-  context 'with non-existing config' do
-    let(:config_file) { 'spec/fixtures/config/non_existing_config.yml'}
-
-    describe '.app_name' do
-      it 'returns nil' do
-        expect(subject.app_name).to be_nil
-      end
-    end
-
-    describe '.is_valid?' do
-      it 'returns false' do
-        expect(subject.valid?).to be_falsey
-      end
-    end
-
-    describe '.is_present?' do
-      it 'returns false' do
-        expect(subject.present?).to be_falsey
-      end
-    end
-  end
-
-  context 'with valid but non rails config' do
-    let(:config_file) { 'spec/fixtures/config/valid_config.yml'}
-
-    describe '.app_name' do
-      it 'returns app name value from config' do
-        expect(subject.app_name).to eq('appmap')
-      end
-    end
-
-    it 'is valid' do
-      expect(subject.errors).to eq(['AppMap auto-configuration is currently not available for non Rails projects'])
-    end
-
-    describe '.is_present?' do
-      it 'returns true' do
-        expect(subject.present?).to be_truthy
-      end
-    end
-  end
-
-  context 'with maximal valid config' do
-    let(:config_file) { 'spec/fixtures/config/maximal_config.yml'}
-
-    it 'is valid' do
-      expect(subject.errors).to eq(['AppMap auto-configuration is currently not available for non Rails projects'])
-    end
-  end
-
-  context 'with invalid YAML config' do
-    let(:config_file) { 'spec/fixtures/config/invalid_yaml_config.yml'}
-
-    describe '.app_name' do
-      it 'returns app name value from config' do
-        expect(subject.app_name).to be_nil
-      end
-    end
-
-    describe '.is_valid?' do
-      it 'returns false' do
-        expect(subject.valid?).to be_falsey
-      end
-    end
-
-    describe '.is_present?' do
-      it 'return true' do
-        expect(subject.present?).to be_truthy
-      end
-    end
-  end
-
-  context 'with incomplete config' do
-    let(:config_file) { 'spec/fixtures/config/incomplete_config.yml'}
-
-    describe '.app_name' do
-      it 'returns nil' do
-        expect(subject.app_name).to eq('app')
-      end
-    end
-
-    describe '.is_valid?' do
-      it 'guesses paths and returns true ' do
-        expect(subject.valid?).to be_falsey
-      end
-    end
-
-    describe '.is_present?' do
-      it 'returns true' do
-        expect(subject.present?).to be_truthy
-      end
-    end
-  end
-end

data/spec/service/integration_test_path_finder_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'appmap/service/integration_test_path_finder'
-
-describe AppMap::Service::IntegrationTestPathFinder do
-  subject { described_class.new('./spec/fixtures/rails6_users_app/') }
-
-  describe '.count' do
-    it 'counts existing paths' do
-      expect(subject.count_paths).to be(3)
-    end
-  end
-
-  describe '.find' do
-    it 'finds paths' do
-      expect(subject.find).to eq({
-        rspec: %w[spec/controllers],
-        minitest: %w[test/controllers test/integration],
-        cucumber: []
-      })
-    end
-  end
-end

data/spec/service/validator/violation_spec.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'appmap/service/validator/violation'
-
-describe AppMap::Service::Validator::Violation do
-  describe '.error' do
-    let(:message) { 'error' }
-
-    context 'with default parameters' do
-      subject { described_class.error(message: :message) }
-
-      it 'builds an error' do
-        expect(subject.level).to be :error
-        expect(subject.message).to be :message
-      end
-    end
-
-    context 'with default parameters' do
-      subject do
-        described_class.error(
-          message: :message,
-          setting: :setting,
-          filename: :filename,
-          detailed_message: :detailed_message,
-          help_urls: :help_urls
-        )
-      end
-
-      let(:filename) { 'filename' }
-      let(:setting) { 'setting' }
-      let(:detailed_message) { 'details' }
-      let(:help_urls) { %w[123 456] }
-
-      it 'builds an error' do
-        expect(subject.level).to be :error
-        expect(subject.message).to be :message
-        expect(subject.setting).to be :setting
-        expect(subject.detailed_message).to be :detailed_message
-        expect(subject.help_urls).to be :help_urls
-      end
-    end
-
-    describe '.warning' do
-      let(:message) { 'warning' }
-
-      context 'with default parameters' do
-        subject { described_class.warning(message: :message) }
-
-        it 'builds an error' do
-          expect(subject.level).to be :warning
-          expect(subject.message).to be :message
-        end
-      end
-    end
-
-    describe '#to_hash' do
-      subject { described_class.warning(message: :message) }
-
-      let(:message) { 'warning' }
-
-      it 'returns correct hash' do
-        expect(subject.to_h['level']).to be :warning
-        expect(subject.to_h['message']).to be :message
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,37 +0,0 @@
-require 'rspec'
-require 'net/http'
-require 'json'
-require 'yaml'
-require 'English'
-require 'byebug'
-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"
-  config.profile_examples = true
-end
-
-# Re-run the Rails specs without re-generating the data. This is useful for efficiently enhancing and
-# debugging the test itself.
-def use_existing_data?
-  ENV['USE_EXISTING_DATA'] == 'true'
-end
-
-def ruby_2?
-  RUBY_VERSION.split('.')[0].to_i == 2
-end
-
-shared_context 'collect events' do
-  def collect_events(tracer)
-    [].tap do |events|
-      while tracer.event?
-        events << tracer.next_event.to_h
-      end
-    end.map(&AppMap::Util.method(:sanitize_event))
-  end
-end

data/spec/swagger/swagger_spec.rb

@@ -1,85 +0,0 @@
-require_relative '../rails_spec_helper'
-
-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'
-
-  unless use_existing_data?
-    before(:all) do
-      @app.run_cmd './bin/rake appmap:swagger'
-    end
-  end
-
-  # The swagger-building logic is mostly in the JS code. So what we are really testing here
-  # is the Rails integration - the rake task and integration with the appmap.yml.
-  it 'generates openapi_stable.yml' do
-    swagger = YAML.load(File.read(File.join(tmpdir, 'swagger', 'openapi_stable.yaml'))).deep_symbolize_keys
-
-    expect(swagger).to eq(YAML.load(<<~YAML
-      :openapi: 3.0.1
-      :info:
-        :title: Usersapp API
-        :version: 1.1.0
-      :paths:
-        :/api/users:
-          :get:
-            :responses:
-              :200:
-                :content:
-                  :application/json: {}
-            :requestBody:
-              :content: {}
-          :post:
-            :responses:
-              :201:
-                :content:
-                  :application/json: {}
-              :422:
-                :content:
-                  :application/json: {}
-            :requestBody:
-              :content:
-                :application/x-www-form-urlencoded:
-                  :schema:
-                    :type: object
-                    :properties:
-                      :login:
-                        :type: string
-                      :password:
-                        :type: string
-                      :user:
-                        :type: object
-                        :properties:
-                          :login:
-                            :type: string
-                          :password:
-                            :type: string
-        :/users:
-          :get:
-            :responses:
-              :200:
-                :content:
-                  :text/html: {}
-        :/users/{id}:
-          :get:
-            :responses:
-              :200:
-                :content:
-                  :text/plain: {}
-            :parameters:
-            - :name: id
-              :in: path
-              :schema:
-                :type: string
-              :required: true
-      :components:
-        :securitySchemes: {}
-      :servers:
-      - :url: http://{defaultHost}
-        :variables:
-          :defaultHost:
-            :default: localhost:3000
-      YAML
-    ))
-  end
-end

data/spec/util_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'appmap/util'
-
-describe AppMap::Util do
-  describe 'scenario_filename' do
-    let(:subject) { AppMap::Util.method(:scenario_filename) }
-    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
-  describe 'swaggerize path' do
-    it 'replaces rails-style parameters' do
-      expect(AppMap::Util.swaggerize_path('/org/:org_id(.:format)')).to eq('/org/{org_id}')
-    end
-
-    it 'strips the format specifier' do
-      expect(AppMap::Util.swaggerize_path('/org(.:format)')).to eq('/org')
-    end
-
-    it 'ignores malformed parameter specs' do
-      expect(AppMap::Util.swaggerize_path('/org/o:rg_id')).to eq('/org/o:rg_id')
-    end
-
-    it 'ignores already swaggerized paths' do
-      expect(AppMap::Util.swaggerize_path('/org/{org_id}')).to eq('/org/{org_id}')
-    end
-  end
-end

data/test/agent_setup_init_test.rb

@@ -1,39 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class AgentSetupInitTest < Minitest::Test
-  CONFIG_FILENAME = '123.yml'
-  EXPECTED_CONFIG_CONTENT = %(---
-name: appmap-ruby
-packages:
-- path: lib
-language: ruby
-appmap_dir: tmp/appmap
-)
-
-  def test_init_when_config_exists
-    output = `./exe/appmap-agent-init`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = JSON.pretty_generate({
-      configuration: {
-        filename: 'appmap.yml',
-        contents: EXPECTED_CONFIG_CONTENT
-      }
-    })
-    assert_equal expected, output.strip
-  end
-
-  def test_init_with_custom_config_filename
-    output = `./exe/appmap-agent-init -c #{CONFIG_FILENAME}`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = JSON.pretty_generate({
-      configuration: {
-        filename: CONFIG_FILENAME,
-        contents: EXPECTED_CONFIG_CONTENT
-      }
-    })
-    assert_equal expected, output.strip
-  end
-end

data/test/agent_setup_status_test.rb

@@ -1,84 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class AgentSetupInitTest < Minitest::Test
-  def test_status_gem
-    output = `./exe/appmap-agent-status`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = {
-      test_commands: [],
-      properties: {
-        config: {
-          app: 'AppMap Rubygem',
-          present: true,
-          valid: false
-        },
-        project: {
-          agentVersion: AppMap::VERSION,
-          language: 'ruby',
-          remoteRecordingCapable: false,
-          integrationTests: false
-        }
-      }
-    }
-    assert_equal JSON.pretty_generate(expected), output.strip
-  end
-
-  def test_status_rails_app
-    output = `cd spec/fixtures/rails6_users_app && bundle exec ../../../exe/appmap-agent-status`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    expected = {
-      test_commands: [
-        {
-          framework: :rspec,
-          command: {
-            program: 'bundle',
-            args: %w[exec rspec ./spec/controllers],
-            environment: {
-              APPMAP: 'true',
-              DISABLE_SPRING: 'true'
-            }
-          }
-        },
-        {
-          framework: :minitest,
-          command: {
-            program: 'bundle',
-            args: %w[exec ruby ./test/controllers],
-            environment: {
-              APPMAP: 'true',
-              DISABLE_SPRING: 'true'
-            }
-          }
-        },
-        {
-          framework: :minitest,
-          command: {
-            program: 'bundle',
-            args: %w[exec ruby ./test/integration],
-            environment: {
-              APPMAP: 'true',
-              DISABLE_SPRING: 'true'
-            }
-          }
-        }
-      ],
-      properties: {
-        config: {
-          app: 'rails6_users_app',
-          present: true,
-          valid: false
-        },
-        project: {
-          agentVersion: AppMap::VERSION,
-          language: 'ruby',
-          remoteRecordingCapable: false,
-          integrationTests: true
-        }
-      }
-    }
-    assert_equal JSON.pretty_generate(expected), output.strip
-  end
-end

data/test/agent_setup_validate_test.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-schema_path = File.expand_path('../../config-schema.yml', __FILE__)
-CONFIG_SCHEMA = YAML.safe_load(File.read(schema_path))
-class AgentSetupValidateTest < Minitest::Test
-  NON_EXISTING_CONFIG_FILENAME = '123.yml'
-  INVALID_YAML_CONFIG_FILENAME = 'spec/fixtures/config/invalid_yaml_config.yml'
-  INVALID_CONFIG_FILENAME = 'spec/fixtures/config/invalid_config.yml'
-  MISSING_PATH_OR_GEM_CONFIG_FILENAME = 'spec/fixtures/config/missing_path_or_gem.yml'
-
-  def check_output(output, expected_errors)
-    expected = JSON.pretty_generate(
-      {
-        version: 2,
-        errors: expected_errors,
-        schema: CONFIG_SCHEMA
-      }
-    )
-    assert_equal(expected, output.strip)
-  end
-    
-  def test_init_when_config_exists
-    output = `./exe/appmap-agent-validate`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    check_output(output, [
-      {
-        level: :error,
-        message: 'AppMap auto-configuration is currently not available for non Rails projects'
-      }
-    ])
-  end
-
-  def test_init_with_non_existing_config_file
-    output = `./exe/appmap-agent-validate -c #{NON_EXISTING_CONFIG_FILENAME}`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    check_output(output, [
-      {
-        level: :error,
-        message: 'AppMap auto-configuration is currently not available for non Rails projects'
-      },
-      {
-        level: :error,
-        filename: NON_EXISTING_CONFIG_FILENAME,
-        message: "AppMap configuration #{NON_EXISTING_CONFIG_FILENAME} file does not exist"
-      }
-    ])
-  end
-
-  def test_init_with_invalid_YAML
-    output = `./exe/appmap-agent-validate -c #{INVALID_YAML_CONFIG_FILENAME}`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    check_output(output, [
-      {
-        level: :error,
-        message: 'AppMap auto-configuration is currently not available for non Rails projects'
-      },
-      {
-        level: :error,
-        filename: INVALID_YAML_CONFIG_FILENAME,
-        message: "AppMap configuration #{INVALID_YAML_CONFIG_FILENAME} is not valid YAML",
-        detailed_message: "(#{INVALID_YAML_CONFIG_FILENAME}): " \
-          'did not find expected key while parsing a block mapping at line 1 column 1'
-      }
-    ])
-  end
-
-  def test_init_with_invalid_data_config
-    output = `./exe/appmap-agent-validate -c #{INVALID_CONFIG_FILENAME}`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    check_output(output, [
-      {
-        level: :error,
-        message: 'AppMap auto-configuration is currently not available for non Rails projects'
-      },
-      {
-        level: :error,
-        filename: INVALID_CONFIG_FILENAME,
-        message: "AppMap configuration #{INVALID_CONFIG_FILENAME} could not be loaded",
-        detailed_message: "no implicit conversion of String into Integer"
-      }
-    ])
-  end
-
-  def test_init_with_missing_package_key
-    output = `./exe/appmap-agent-validate -c #{MISSING_PATH_OR_GEM_CONFIG_FILENAME}`
-    assert_equal 0, $CHILD_STATUS.exitstatus
-    check_output(output, [
-      {
-        level: :error,
-        message: 'AppMap auto-configuration is currently not available for non Rails projects'
-      },
-      {
-        level: :error,
-        filename: MISSING_PATH_OR_GEM_CONFIG_FILENAME,
-        message: "AppMap configuration #{MISSING_PATH_OR_GEM_CONFIG_FILENAME} could not be loaded",
-        detailed_message: "AppMap config 'package' element should specify 'gem' or 'path'"
-      }
-    ])
-  end
-end