appmap 0.35.2 → 0.39.0

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

data/spec/rspec_feature_metadata_spec.rb

@@ -3,30 +3,29 @@
 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
+  include_examples '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 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
+      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)) }
+    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
+    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)
+        expect(appmap).to include(<<-METADATA.strip)
   feature: Create a user
   feature_group: User
-      METADATA
+        METADATA
+      end
     end
   end
 end

data/test/expectations/openssl_test_key_sign1.json

@@ -0,0 +1,55 @@
+[
+  {
+    "name": "lib",
+    "type": "package",
+    "children": [
+      {
+        "name": "Example",
+        "type": "class",
+        "children": [
+          {
+            "name": "sign",
+            "type": "function",
+            "location": "lib/openssl_key_sign.rb:10",
+            "static": true,
+            "source": "  def Example.sign\n    key = OpenSSL::PKey::RSA.new 2048\n\n    document = 'the document'\n\n    digest = OpenSSL::Digest::SHA256.new\n    key.sign digest, document\n  end\n"
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "name": "openssl",
+    "type": "package",
+    "children": [
+      {
+        "name": "OpenSSL",
+        "type": "class",
+        "children": [
+          {
+            "name": "PKey",
+            "type": "class",
+            "children": [
+              {
+                "name": "PKey",
+                "type": "class",
+                "children": [
+                  {
+                    "name": "sign",
+                    "type": "function",
+                    "location": "OpenSSL::PKey::PKey#sign",
+                    "static": false,
+                    "labels": [
+                      "security",
+                      "crypto"
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+]