mmtrix_rpm 1.0.0.1

data/test/mmtrix/agent_test.rb

@@ -0,0 +1,471 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require 'ostruct'
+
+module Mmtrix
+  # mostly this class just passes through to the active agent
+  # through the agent method or the control instance through
+  # Mmtrix::Control.instance . But it's nice to make sure.
+  class MainAgentTest < Minitest::Test
+    include Mmtrix::Agent::MethodTracer
+
+    def setup
+      Mmtrix::Agent.drop_buffered_data
+      Mmtrix::Agent.manual_start
+      Mmtrix::Agent.reset_config
+      Mmtrix::Agent.instance.stubs(:start_worker_thread)
+    end
+
+    def teardown
+      Mmtrix::Agent::TransactionState.tl_clear_for_testing
+    end
+
+    def test_shutdown
+      mock_agent = mocked_agent
+      mock_agent.expects(:shutdown)
+      Mmtrix::Agent.shutdown
+    end
+
+    def test_shutdown_removes_manual_startup_config
+      Mmtrix::Agent.manual_start(:monitor_mode => true, :license_key => "a" * 40, :some_absurd_setting => true)
+      assert Mmtrix::Agent.config[:some_absurd_setting]
+      Mmtrix::Agent.shutdown
+      assert !Mmtrix::Agent.config[:some_absurd_setting]
+    end
+
+    def test_shutdown_removes_server_config
+      Mmtrix::Agent.manual_start(:monitor_mode => true, :license_key => "a" * 40)
+      Mmtrix::Agent.instance.service = default_service
+      Mmtrix::Agent.instance.finish_setup('agent_config' =>
+                                            { 'data_report_period' => 10 })
+      assert_equal 10, Mmtrix::Agent.config[:data_report_period]
+      Mmtrix::Agent.shutdown
+      assert_equal 60, Mmtrix::Agent.config[:data_report_period]
+    end
+
+    def test_finish_setup_applied_server_side_config
+      with_config_low_priority({
+                    :'transction_tracer.enabled' => true,
+                    :'error_collector.enabled' => true }) do
+        Mmtrix::Agent.instance.finish_setup(
+         'agent_config' => { 'transaction_tracer.enabled' => false },
+                                         'collect_errors' => false)
+        refute Mmtrix::Agent.config[:'transaction_tracer.enabled']
+        refute Mmtrix::Agent.config[:'error_collector.enabled']
+      end
+    end
+
+    def test_after_fork
+      mock_agent = mocked_agent
+      mock_agent.expects(:after_fork).with({})
+      Mmtrix::Agent.after_fork
+    end
+
+    def test_reset_stats
+      mock_agent = mocked_agent
+      mock_agent.expects(:drop_buffered_data)
+      Mmtrix::Agent.reset_stats
+    end
+
+    def test_manual_start_default
+      mock_control = mocked_control
+      mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => true})
+      Mmtrix::Agent.manual_start
+    end
+
+    def test_manual_start_with_opts
+      mock_control = mocked_control
+      mock_control.expects(:init_plugin).with({:agent_enabled => true, :sync_startup => false})
+      Mmtrix::Agent.manual_start(:sync_startup => false)
+    end
+
+    def test_manual_start_starts_channel_listener
+      Mmtrix::Agent::PipeChannelManager.listener.expects(:start).at_least_once
+      Mmtrix::Agent.manual_start(:start_channel_listener => true)
+      Mmtrix::Agent.shutdown
+    end
+
+    def test_manual_start_kicks_dependency_check_again
+      with_config(:monitor_mode => true, :license_key => "a" * 40, :sync_startup => true) do
+        Mmtrix::Agent.manual_start
+        assert Mmtrix::Agent.instance.started?
+
+        Mmtrix::Control.instance.stubs(:init_config)
+        DependencyDetection.expects(:detect!).once
+
+        Mmtrix::Agent.manual_start
+      end
+    end
+
+    def test_get_stats
+      agent = mocked_agent
+      mock_stats_engine = mock('stats_engine')
+      agent.expects(:stats_engine).returns(mock_stats_engine)
+      mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
+      Mmtrix::Agent.get_stats('Custom/test/metric')
+    end
+
+    # note that this is the same as get_stats above, they're just aliases
+    def test_get_stats_no_scope
+      agent = mocked_agent
+      mock_stats_engine = mock('stats_engine')
+      agent.expects(:stats_engine).returns(mock_stats_engine)
+      mock_stats_engine.expects(:get_stats).with('Custom/test/metric', false)
+      Mmtrix::Agent.get_stats_no_scope('Custom/test/metric')
+    end
+
+    def test_agent_logs_warning_when_not_started
+      with_unstarted_agent do
+        expects_logging(:warn, includes("hasn't been started"))
+        Mmtrix::Agent.agent
+      end
+    end
+
+    def test_agent_can_shut_down_when_not_started
+      with_unstarted_agent do
+        Mmtrix::Agent.shutdown
+      end
+    end
+
+    def test_agent_when_started
+      old_agent = Mmtrix::Agent.agent
+      Mmtrix::Agent.instance_eval { @agent = 'not nil' }
+      assert_equal('not nil', Mmtrix::Agent.agent, "should return the value from @agent")
+      Mmtrix::Agent.instance_eval { @agent = old_agent }
+    end
+
+    def test_abort_transaction_bang
+      Mmtrix::Agent::Transaction.expects(:abort_transaction!)
+      Mmtrix::Agent.abort_transaction!
+    end
+
+    def test_is_transaction_traced_true
+      Mmtrix::Agent::TransactionState.tl_get.record_tt = true
+      assert_equal(true, Mmtrix::Agent.tl_is_transaction_traced?, 'should be true since the thread local is set')
+    end
+
+    def test_is_transaction_traced_blank
+      Mmtrix::Agent::TransactionState.tl_get.record_tt = nil
+      assert_equal(true, Mmtrix::Agent.tl_is_transaction_traced?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_transaction_traced_false
+      Mmtrix::Agent::TransactionState.tl_get.record_tt = false
+      assert_equal(false, Mmtrix::Agent.tl_is_transaction_traced?, 'should be false since the thread local is false')
+    end
+
+    def test_is_sql_recorded_true
+      Mmtrix::Agent::TransactionState.tl_get.record_sql = true
+      assert_equal(true, Mmtrix::Agent.tl_is_sql_recorded?, 'should be true since the thread local is set')
+    end
+
+    def test_is_sql_recorded_blank
+      Mmtrix::Agent::TransactionState.tl_get.record_sql = nil
+      assert_equal(true, Mmtrix::Agent.tl_is_sql_recorded?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_sql_recorded_false
+      Mmtrix::Agent::TransactionState.tl_get.record_sql = false
+      assert_equal(false, Mmtrix::Agent.tl_is_sql_recorded?, 'should be false since the thread local is false')
+    end
+
+    def test_is_execution_traced_true
+      Mmtrix::Agent::TransactionState.tl_get.untraced = [true, true]
+      assert_equal(true, Mmtrix::Agent.tl_is_execution_traced?, 'should be true since the thread local is set')
+    end
+
+    def test_is_execution_traced_blank
+      Mmtrix::Agent::TransactionState.tl_get.untraced = nil
+      assert_equal(true, Mmtrix::Agent.tl_is_execution_traced?, 'should be true since the thread local is not set')
+    end
+
+    def test_is_execution_traced_empty
+      Mmtrix::Agent::TransactionState.tl_get.untraced = []
+      assert_equal(true, Mmtrix::Agent.tl_is_execution_traced?, 'should be true since the thread local is an empty array')
+    end
+
+    def test_is_execution_traced_false
+      Mmtrix::Agent::TransactionState.tl_get.untraced = [true, false]
+      assert_equal(false, Mmtrix::Agent.tl_is_execution_traced?, 'should be false since the thread local stack has the last element false')
+    end
+
+    def test_instance
+      Mmtrix::Agent.manual_start
+      assert_equal(Mmtrix::Agent.agent, Mmtrix::Agent.instance, "should return the same agent for both identical methods")
+    end
+
+    def test_register_report_channel
+      Mmtrix::Agent.register_report_channel(:channel_id)
+      assert Mmtrix::Agent::PipeChannelManager.channels[:channel_id] \
+        .kind_of?(Mmtrix::Agent::PipeChannelManager::Pipe)
+      Mmtrix::Agent::PipeChannelManager.listener.close_all_pipes
+    end
+
+    def test_record_metric
+      dummy_engine = Mmtrix::Agent.agent.stats_engine
+      dummy_engine.expects(:tl_record_unscoped_metrics).with('foo', 12)
+      Mmtrix::Agent.record_metric('foo', 12)
+    end
+
+    def test_record_metric_accepts_hash
+      dummy_engine = Mmtrix::Agent.agent.stats_engine
+      stats_hash = {
+        :count => 12,
+        :total => 42,
+        :min   => 1,
+        :max   => 5,
+        :sum_of_squares => 999
+      }
+      expected_stats = Mmtrix::Agent::Stats.new()
+      expected_stats.call_count = 12
+      expected_stats.total_call_time = 42
+      expected_stats.total_exclusive_time = 42
+      expected_stats.min_call_time = 1
+      expected_stats.max_call_time = 5
+      expected_stats.sum_of_squares = 999
+      dummy_engine.expects(:tl_record_unscoped_metrics).with('foo', expected_stats)
+      Mmtrix::Agent.record_metric('foo', stats_hash)
+    end
+
+    def test_record_metric_sets_default_hash_values_for_missing_keys
+      dummy_engine = Mmtrix::Agent.agent.stats_engine
+      incomplete_stats_hash = {
+        :count => 12,
+        :max   => 5,
+        :sum_of_squares => 999
+      }
+
+      expected_stats = Mmtrix::Agent::Stats.new()
+      expected_stats.call_count = 12
+      expected_stats.total_call_time = 0.0
+      expected_stats.total_exclusive_time = 0.0
+      expected_stats.min_call_time = 0.0
+      expected_stats.max_call_time = 5
+      expected_stats.sum_of_squares = 999
+
+      dummy_engine.expects(:tl_record_unscoped_metrics).with('foo', expected_stats)
+      Mmtrix::Agent.record_metric('foo', incomplete_stats_hash)
+    end
+
+    def test_increment_metric
+      dummy_engine = Mmtrix::Agent.agent.stats_engine
+      dummy_stats = mock
+      dummy_stats.expects(:increment_count).with(12)
+      dummy_engine.expects(:tl_record_unscoped_metrics).with('foo').yields(dummy_stats)
+      Mmtrix::Agent.increment_metric('foo', 12)
+    end
+
+    class Transactor
+      include Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+      def txn
+        yield
+      end
+      add_transaction_tracer :txn
+
+      def task_txn
+        yield
+      end
+      add_transaction_tracer :task_txn, :category => :task
+    end
+
+    def test_set_transaction_name
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.txn do
+        Mmtrix::Agent.set_transaction_name('new_name')
+      end
+      assert_metrics_recorded(['Controller/new_name'])
+    end
+
+    def test_get_transaction_name_returns_nil_outside_transaction
+      assert_equal nil, Mmtrix::Agent.get_transaction_name
+    end
+
+    def test_get_transaction_name_returns_the_default_txn_name
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.txn do
+        assert_equal 'Mmtrix::MainAgentTest::Transactor/txn', Mmtrix::Agent.get_transaction_name
+      end
+    end
+
+    def test_get_transaction_name_returns_what_I_set
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.txn do
+        Mmtrix::Agent.set_transaction_name('a_new_name')
+        assert_equal 'a_new_name', Mmtrix::Agent.get_transaction_name
+      end
+    end
+
+    def test_get_txn_name_and_set_txn_name_preserves_category
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.txn do
+        Mmtrix::Agent.set_transaction_name('a_new_name', :category => :task)
+        new_name = Mmtrix::Agent.get_transaction_name + "2"
+        Mmtrix::Agent.set_transaction_name(new_name)
+      end
+      assert_metrics_recorded 'OtherTransaction/Background/a_new_name2'
+    end
+
+    def test_set_transaction_name_applies_proper_scopes
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.txn do
+        trace_execution_scoped('Custom/something') {}
+        Mmtrix::Agent.set_transaction_name('new_name')
+      end
+
+      assert_metrics_recorded([
+        'Custom/something',
+        'Controller/new_name'
+      ])
+    end
+
+    def test_set_transaction_name_sets_tt_name
+      sampler = Mmtrix::Agent.instance.transaction_sampler
+      Transactor.new.txn do
+        Mmtrix::Agent.set_transaction_name('new_name')
+      end
+      assert_equal 'Controller/new_name', sampler.last_sample.transaction_name
+    end
+
+    def test_set_transaction_name_gracefully_fails_when_frozen
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.txn do
+        Mmtrix::Agent::Transaction.tl_current.freeze_name_and_execute_if_not_ignored do
+          Mmtrix::Agent.set_transaction_name('new_name')
+        end
+      end
+      refute_metrics_recorded('Controller/new_name')
+    end
+
+    def test_set_transaction_name_applies_category
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.txn do
+        Mmtrix::Agent.set_transaction_name('new_name', :category => :task)
+      end
+
+      assert_metrics_recorded 'OtherTransaction/Background/new_name'
+
+      Transactor.new.txn do
+        Mmtrix::Agent.set_transaction_name('new_name', :category => :rack)
+      end
+
+      assert_metrics_recorded 'Controller/Rack/new_name'
+
+      Transactor.new.txn do
+        Mmtrix::Agent.set_transaction_name('new_name', :category => :sinatra)
+      end
+
+      assert_metrics_recorded 'Controller/Sinatra/new_name'
+    end
+
+    def test_set_transaction_name_uses_current_txn_category_default
+      engine = Mmtrix::Agent.instance.stats_engine
+      engine.reset!
+      Transactor.new.task_txn do
+        Mmtrix::Agent.set_transaction_name('new_name')
+      end
+      assert_metrics_recorded 'OtherTransaction/Background/new_name'
+    end
+
+    # It's not uncommon for customers to conclude a rescue block with a call to
+    # notice_error.  We should always return nil, which mean less folks
+    # unexpectedly get a noticed error Hash returned from their methods.
+    def test_notice_error_returns_nil
+      begin
+        raise "WTF"
+      rescue => e
+        assert_equal nil, ::Mmtrix::Agent.notice_error(e)
+      end
+    end
+
+    def test_eventing_helpers
+      called = false
+      Mmtrix::Agent.subscribe(:boo) { called = true }
+      Mmtrix::Agent.notify(:boo)
+      assert called
+    end
+
+    def test_ignore_transaction_works
+      in_transaction do |txn|
+        Mmtrix::Agent.ignore_transaction
+        assert txn.ignore?
+      end
+
+      assert_empty Mmtrix::Agent.instance.transaction_sampler.harvest!
+    end
+
+    # The assumption is that txn.ignore_apdex! works as expected, and is tested elsewhere.
+    def test_ignore_apdex_works
+      in_transaction do |txn|
+        Mmtrix::Agent.ignore_apdex
+        assert txn.ignore_apdex?
+      end
+    end
+
+    # The assumption is that txn.ignore_enduser! works as expected, and is tested elsewhere.
+    def test_ignore_enduser_works
+      in_transaction do |txn|
+        Mmtrix::Agent.ignore_enduser
+        assert txn.ignore_enduser?
+      end
+    end
+
+    def test_add_custom_parameters_deprecated
+      Mmtrix::Agent::Deprecator.expects(:deprecate)
+      Mmtrix::Agent.add_custom_parameters(:is => "bunk")
+    end
+
+    def test_add_request_parameters_deprecated
+      Mmtrix::Agent::Deprecator.expects(:deprecate)
+      Mmtrix::Agent.add_request_parameters(:is => "bunk")
+    end
+
+    def test_set_user_attributes_deprecated
+      Mmtrix::Agent::Deprecator.expects(:deprecate)
+      Mmtrix::Agent.set_user_attributes(:is => "bunk")
+    end
+
+    private
+
+    def with_unstarted_agent
+      old_agent = Mmtrix::Agent.agent
+      Mmtrix::Agent.instance_eval { @agent = nil }
+      yield
+    ensure
+      Mmtrix::Agent.instance_eval { @agent = old_agent }
+    end
+
+    def mocked_agent
+      agent = mock('agent')
+      Mmtrix::Agent.stubs(:agent).returns(agent)
+      agent
+    end
+
+    def mocked_control
+      server = Mmtrix::Control::Server.new('localhost', 3000)
+      control = OpenStruct.new(:license_key => 'abcdef',
+                               :server => server)
+      control.instance_eval do
+        def [](key)
+          nil
+        end
+
+        def fetch(k,d)
+          nil
+        end
+      end
+
+      Mmtrix::Control.stubs(:instance).returns(control)
+      control
+    end
+  end
+end

data/test/mmtrix/cli/commands/deployments_test.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'mmtrix/cli/command'
+require 'mmtrix/cli/commands/deployments'
+
+class Mmtrix::Cli::DeploymentsTest < Minitest::Test
+
+  def setup
+    Mmtrix::Cli::Deployments.class_eval do
+      attr_accessor :messages, :exit_status, :errors, :revision, :license_key
+      def err(message); @errors = @errors ? @errors + message : message; end
+      def info(message); @messages = @messages ? @messages + message : message; end
+      def just_exit(status=0); @exit_status ||= status; end
+    end
+    @config = { :license_key => 'a' * 40,
+                :config_path => 'test/config/mmtrix.yml' }
+    Mmtrix::Agent.config.add_config_for_testing(@config)
+  end
+
+  def teardown
+    super
+    return unless @deployment
+    puts @deployment.errors
+    puts @deployment.messages
+    puts @deployment.exit_status
+    Mmtrix::Agent.config.remove_config(@config)
+  end
+
+
+  def test_help
+    begin
+      Mmtrix::Cli::Deployments.new "-h"
+      fail "should have thrown"
+    rescue Mmtrix::Cli::Command::CommandFailure => c
+      assert_match(/^Usage/, c.message)
+    end
+  end
+
+  def test_bad_command
+    assert_raises Mmtrix::Cli::Command::CommandFailure do
+      Mmtrix::Cli::Deployments.new ["-foo", "bar"]
+    end
+  end
+
+  def test_interactive
+    mock_the_connection
+    @deployment = Mmtrix::Cli::Deployments.new(:appname => 'APP',
+                                  :revision => 3838,
+                                  :user => 'Bill',
+                                  :description => "Some lengthy description")
+    assert_nil @deployment.exit_status
+    assert_nil @deployment.errors
+    assert_equal '3838', @deployment.revision
+    @deployment.run
+    @deployment = nil
+  end
+
+  def test_command_line_run
+    mock_the_connection
+    #    @mock_response.expects(:body).returns("<xml>deployment</xml>")
+    @deployment = Mmtrix::Cli::Deployments.new(%w[-a APP -r 3838 --user=Bill] << "Some lengthy description")
+    assert_nil @deployment.exit_status
+    assert_nil @deployment.errors
+    assert_equal '3838', @deployment.revision
+    @deployment.run
+
+    # This should pass because it's a bogus deployment
+    #assert_equal 1, @deployment.exit_status
+    #assert_match /Unable to upload/, @deployment.errors
+
+    @deployment = nil
+  end
+
+  def test_error_if_no_license_key
+    with_config(:license_key => '') do
+      assert_raises Mmtrix::Cli::Command::CommandFailure do
+        deployment = Mmtrix::Cli::Deployments.new(%w[-a APP -r 3838 --user=Bill] << "Some lengthy description")
+        deployment.run
+      end
+    end
+  end
+
+  def test_error_if_failed_yaml
+    Mmtrix::Agent::Configuration::YamlSource.any_instance.stubs(:failed?).returns(true)
+
+    assert_raises Mmtrix::Cli::Command::CommandFailure do
+      deployment = Mmtrix::Cli::Deployments.new(%w[-a APP -r 3838 --user=Bill] << "Some lengthy description")
+      deployment.run
+    end
+  end
+
+  def test_with_specified_license_key
+    mock_the_connection
+    @deployment = Mmtrix::Cli::Deployments.new(:appname => 'APP',
+                                                     :revision => 3838,
+                                                     :user => 'Bill',
+                                                     :description => "Some lengthy description",
+                                                     :license_key => 'b' * 40)
+    assert_nil @deployment.exit_status
+    assert_nil @deployment.errors
+    assert_equal 'b' * 40, @deployment.license_key
+    @deployment.run
+    @deployment = nil
+  end
+
+  def test_with_unspecified_license_key
+    mock_the_connection
+    @deployment = Mmtrix::Cli::Deployments.new(:appname => 'APP',
+                                                     :revision => 3838,
+                                                     :user => 'Bill',
+                                                     :description => "Some lengthy description")
+    assert_nil @deployment.exit_status
+    assert_nil @deployment.errors
+    assert_equal 'a' * 40, @deployment.license_key
+    @deployment.run
+    @deployment = nil
+  end
+
+  private
+
+  def mock_the_connection
+    mock_connection = mock()
+    @mock_response = mock()
+    @mock_response.expects(:is_a?).with(Net::HTTPSuccess).returns(true)
+    mock_connection.expects(:request).returns(@mock_response)
+    Mmtrix::Agent::MmtrixService.any_instance.stubs(:http_connection).returns(mock_connection)
+  end
+end

data/test/mmtrix/cli/commands/install_test.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require File.expand_path(File.join(File.dirname(__FILE__),'..','..','..','test_helper'))
+require 'mmtrix/cli/command'
+require 'mmtrix/cli/commands/install'
+
+class Mmtrix::Cli::InstallTest < Minitest::Test
+  def test_fails_without_app_name
+    assert_raises(Mmtrix::Cli::Command::CommandFailure) do
+      Mmtrix::Cli::Install.new(["-l", "license"])
+    end
+  end
+
+  def test_basic_run
+    install = Mmtrix::Cli::Install.new(["-l", "license", "app"])
+    assert_equal "license", install.license_key
+    assert_equal "app", install.app_name
+  end
+
+  def test_app_name_with_spaces
+    install = Mmtrix::Cli::Install.new(["-l", "license", "my", "app"])
+    assert_equal "license", install.license_key
+    assert_equal "my app", install.app_name
+  end
+end