dogapi 1.22.0 → 1.23.0

data/tests/test_alerts.rb

@@ -1,38 +0,0 @@
-require 'dogapi'
-require 'time'
-require 'test_base.rb'
-
-class TestAlerts < Minitest::Test
-  include TestBase
-
-  def test_alerts
-    dog = Dogapi::Client.new(@api_key, @app_key)
-
-    query = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100'
-
-    alert_id = dog.alert(query)[1]['id']
-    status, alert = dog.get_alert(alert_id)
-    assert_equal alert['query'], query, alert['query']
-    assert_equal alert['silenced'], false, alert['silenced']
-
-    dog.update_alert(alert_id, query, :silenced => true)
-    status, alert = dog.get_alert(alert_id)
-    assert_equal alert['query'], query, alert['query']
-    assert_equal alert['silenced'], true, alert['silenced']
-
-    dog.delete_alert(alert_id)
-
-    query1 = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100'
-    query2 = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200'
-
-    alert_id1 = dog.alert(query1)[1]['id']
-    alert_id2 = dog.alert(query2)[1]['id']
-    status, alerts = dog.get_all_alerts()
-    alerts = alerts['alerts']
-    alert1 = alerts.select {|a| a['id'] == alert_id1}
-    alert2 = alerts.select {|a| a['id'] == alert_id2}
-    assert_equal alert1[0]['query'], query1, alert1
-    assert_equal alert2[0]['query'], query2, alert2
-
-  end
-end

data/tests/test_base.rb

@@ -1,30 +0,0 @@
-require 'minitest/autorun'
-require 'dogapi'
-require 'time'
-
-module TestBase
-
-  def config_client_test_env
-    @api_key = ENV['DATADOG_API_KEY']
-    @app_key = ENV['DATADOG_APP_KEY']
-    if not @api_key or not @app_key
-      puts "\n"
-      abort "To run tests in your environment, set 'DATADOG_API_KEY' and 'DATADOG_APP_KEY' to appropriate values for your account. Be aware that the tests will submit data, some of which won't be removed at the end.\n\n"
-    end
-  end
-
-  def setup
-    config_client_test_env()
-  end
-
-  def random
-    Kernel.rand 100000
-  end
-
-  def job_number
-    # Get the Travis ENV and use that to 'seed' the dashboard titles, in attempt
-    # to prevent parallel testing conflicts
-    job_number = ENV['TRAVIS_JOB_NUMBER'] || '1'
-  end
-
-end

data/tests/test_client.rb

@@ -1,23 +0,0 @@
-require 'dogapi'
-require 'time'
-require 'test_base.rb'
-
-class TestClient < Minitest::Test
-  include TestBase
-
-  def test_find_localhost
-    val = Dogapi.find_localhost
-    assert !val.nil?
-  end
-
-  def test_metrics
-    # FIXME: actually verify this once there's a way to look at metrics through the api
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    dog_r = Dogapi::Client.new(@api_key)
-
-    dog_r.emit_point('test.metric.metric', 10, :host => 'test.metric.host')
-    dog_r.emit_points('test.metric.metric', [[Time.now-5*60, 0]], :host => 'test.metric.host')
-
-    dog_r.emit_points('test.metric.metric', [[Time.now-60, 20], [Time.now-30, 10], [Time.now, 5]], :tags => ["test:tag.1", "test:tag2"])
-  end
-end

data/tests/test_comments.rb

@@ -1,39 +0,0 @@
-require 'dogapi'
-require 'time'
-require 'test_base.rb'
-
-class TestComments < Minitest::Test
-  include TestBase
-
-
-  def test_comments
-    dog = Dogapi::Client.new(@api_key, @app_key)
-
-    # Create a comment
-    dog.comment('test comment')
-
-    # Create a comment as a user.
-    handle = "carlo+14.1@datadoghq.com"
-    status, comment_response = dog.comment('test comment with handle', :handle => handle)
-    comment = comment_response["comment"]
-    assert_equal "200", status, "Comment did not succeed, response: #{comment_response}"
-
-    sleep 1
-
-    # Reply to a comment.
-    status, reply_response = dog.comment('replying!', :related_event_id => comment["id"])
-    reply = reply_response["comment"]
-    assert_equal "200", status, "Reply did not work, response: #{reply_response}"
-    # HACK: issue #900 on dogweb. id types should be the same.
-    assert_equal comment["id"].to_s, reply["related_event_id"]
-
-    # Update a comment.
-    dog.update_comment(reply["related_event_id"], :message => "Updating the comment")
-
-    # Delete a comment.
-    status, to_delete_response = dog.comment("im dead")
-    to_delete = to_delete_response["comment"]
-    dog.delete_comment(to_delete["id"])
-
-  end
-end

data/tests/test_dashes.rb

@@ -1,85 +0,0 @@
-require 'dogapi'
-require 'time'
-require 'test_base.rb'
-
-class TestDashes < Minitest::Test
-  include TestBase
-
-  def test_dashes
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    now = Time.now.to_i.to_s
-
-    # Create a dashboard.
-    title = "foobar-#{job_number}-#{now}"
-    description = 'desc'
-    graphs =  [{
-      "definition" => {
-        "events" => [],
-        "requests" => [
-          {"q" => "avg:system.mem.free{*}"}
-        ],
-        "viz" => "timeseries"
-      },
-      "title" => "Average Memory Free"
-    }]
-
-    status, dash_response = dog.create_dashboard(title, description, graphs)
-    assert_equal "200", status, "Creation failed, response: #{dash_response}"
-
-    dash_id = dash_response["dash"]["id"]
-
-    # Fetch the dashboard and assert all is well.
-    status, dash_response = dog.get_dashboard(dash_id)
-    assert_equal "200", status, "Fetch failed, response: #{dash_response}"
-    dash = dash_response["dash"]
-    assert_equal title, dash["title"]
-    assert_equal description, dash["description"]
-    assert_equal graphs, dash["graphs"]
-
-    # Update the dashboard.
-    title = "blahfoobar-#{job_number}-#{now}"
-    description = 'asdfdesc'
-    graphs =  [{
-      "definition" => {
-        "events" => [],
-        "requests" => [
-          {"q" => "sum:system.mem.free{*}"}
-        ],
-        "viz" => "timeseries"
-      },
-      "title" => "Sum Memory Free"
-    }]
-    tpl_vars = [{"default" => nil, "prefix" => nil, "name" => "foo"},
-                {"default" => nil, "prefix" => nil, "name" => "bar"}]
-
-    status, dash_response = dog.update_dashboard(dash_id, title, description, graphs, tpl_vars)
-    assert_equal "200", status, "Updated failed, response: #{dash_response}"
-
-    # Fetch the dashboard and assert all is well.
-    status, dash_response = dog.get_dashboard(dash_id)
-    assert_equal "200", status, "Fetch failed, response: #{dash_response}"
-    dash = dash_response["dash"]
-    assert_equal title, dash["title"]
-    assert_equal description, dash["description"]
-    assert_equal graphs, dash["graphs"]
-    assert_equal tpl_vars, dash["template_variables"]
-
-    # Fetch all the dashboards, assert our created one is in the list of all
-    status, dash_response = dog.get_dashboards()
-    assert_equal "200", status, "fetch failed, response: #{dash_response}"
-    dashes = dash_response["dashes"]
-    assert dashes.any? { |d| title == d["title"] }
-    dash = dashes.find { |d| title == d["title"] }
-    assert_equal title, dash["title"]
-    assert_equal dash_id.to_s, dash["id"]
-
-    # Delete the dashboard.
-    status, dash_response = dog.delete_dashboard(dash_id)
-    assert_equal "204", status, "Deleted failed, response: #{dash_response}"
-
-    # Fetch the dashboard and assert all it's gone.
-    status, dash_response = dog.get_dashboard(dash_id)
-    assert_equal "404", status, "Still there failed, response: #{dash_response}"
-
-  end
-end

data/tests/test_embed.rb

@@ -1,194 +0,0 @@
-require 'dogapi'
-require 'time'
-require 'test_base.rb'
-
-class TestEmbed < Minitest::Test
-  include TestBase
-
-  def test_get_all_embeds
-    dog = Dogapi::Client.new(@api_key, @app_key)
-
-    # Attempt API Call
-    status, result = dog.get_all_embeds()
-    # Sanity check results
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    assert result.has_key?("embedded_graphs")
-  end
-
-  def test_create_embed
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    # create an embed using the embed id and verify that it is valid
-    graph_json = '{
-      "viz": "toplist",
-      "requests": [{
-        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
-        "style": {
-          "palette": "dog_classic"
-        },
-        "conditional_formats": [{
-          "palette": "red",
-          "comparator": ">",
-          "value": 50000000000
-        }, {
-          "palette": "green",
-          "comparator": ">",
-          "value": 30000000000
-        }]
-      }]
-    }'
-    timeframe = "1_hour"
-    size = "medium"
-    legend = "no"
-    title = "Sick Title!"
-    description = {
-      :timeframe => timeframe,
-      :size => size,
-      :legend => legend,
-      :title => title
-    }
-    status, result = dog.create_embed(graph_json, description)
-    # Sanity check results
-    assert result["graph_title"] == title
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    assert result["html"].include? "legend=false"
-    assert result["html"].include? "height=300"
-    assert result["html"].include? "width=600"
-  end
-
-  def test_get_embed
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    # Create an Embed to get a valid embed_id
-    graph_json = '{
-      "viz": "toplist",
-      "requests": [{
-        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
-        "style": {
-          "palette": "dog_classic"
-        },
-        "conditional_formats": [{
-          "palette": "red",
-          "comparator": ">",
-          "value": 50000000000
-        }, {
-          "palette": "green",
-          "comparator": ">",
-          "value": 30000000000
-        }]
-      }]
-    }'
-    timeframe = "1_hour"
-    size = "medium"
-    legend = "no"
-    title = "Sick Title!"
-    description = {
-      :timeframe => timeframe,
-      :size => size,
-      :legend => legend,
-      :title => title
-    }
-    status, create_result = dog.create_embed(graph_json, description)
-    # Sanity check results
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    assert create_result["html"].include? "legend=false"
-    assert create_result["html"].include? "height=300"
-    assert create_result["html"].include? "width=600"
-    embed_id = create_result["embed_id"]
-    # Get the embed using that embed id
-    status, embed_without_var = dog.get_embed(embed_id)
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    get_embed_description = {
-      :size => size,
-      :legend => legend,
-      :var => "val"
-    }
-    status, embed_with_var = dog.get_embed(embed_id, get_embed_description)
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    # Verify that the get requests are good
-    assert embed_without_var["html"] == create_result["html"]
-    assert embed_with_var["html"] != embed_without_var["html"]
-    assert embed_with_var["html"].include? "legend=false"
-    assert embed_with_var["html"].include? "height=300"
-    assert embed_with_var["html"].include? "width=600"
-    assert embed_with_var["html"].include? "var=val"
-  end
-
-  def test_enable_embed
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    # Create an Embed to get a valid embed_id
-    graph_json = '{
-      "viz": "toplist",
-      "requests": [{
-        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
-        "style": {
-          "palette": "dog_classic"
-        },
-        "conditional_formats": [{
-          "palette": "red",
-          "comparator": ">",
-          "value": 50000000000
-        }, {
-          "palette": "green",
-          "comparator": ">",
-          "value": 30000000000
-        }]
-      }]
-    }'
-    timeframe = "1_hour"
-    size = "medium"
-    legend = "no"
-    title = "Sick Title!"
-    description = {
-      :timeframe => timeframe,
-      :size => size,
-      :legend => legend,
-      :title => title
-    }
-    status, create_result = dog.create_embed(graph_json, description)
-    # Sanity check results
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    embed_id = create_result["embed_id"]
-    status, result = dog.enable_embed(embed_id)
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    assert result.has_key?("success")
-  end
-
-  def test_revoke_embed
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    # Create an Embed to get a valid embed_id
-    graph_json = '{
-      "viz": "toplist",
-      "requests": [{
-        "q": "top(system.disk.free{$var} by {device}, 10, \'mean\', \'desc\')",
-        "style": {
-          "palette": "dog_classic"
-        },
-        "conditional_formats": [{
-          "palette": "red",
-          "comparator": ">",
-          "value": 50000000000
-        }, {
-          "palette": "green",
-          "comparator": ">",
-          "value": 30000000000
-        }]
-      }]
-    }'
-    timeframe = "1_hour"
-    size = "medium"
-    legend = "no"
-    title = "Sick Title!"
-    description = {
-      :timeframe => timeframe,
-      :size => size,
-      :legend => legend,
-      :title => title
-    }
-    status, create_result = dog.create_embed(graph_json, description)
-    # Sanity check results
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    embed_id = create_result["embed_id"]
-    status, result = dog.revoke_embed(embed_id)
-    assert_equal status, "200", "invalid HTTP response => #{status}"
-    assert result.has_key?("success")
-  end
-end

data/tests/test_monitors.rb

@@ -1,192 +0,0 @@
-require 'dogapi'
-require 'time'
-require 'test_base.rb'
-
-class TestAlerts < Minitest::Test
-  include TestBase
-
-  def test_metric_alerts
-    dog = Dogapi::Client.new(@api_key, @app_key)
-
-    query = 'sum(last_1d):sum:system.net.bytes_rcvd{host:host0} > 100'
-    options = {
-        'silenced' => {'*' => nil},
-        'notify_no_data' => false
-    }
-
-    monitor_id = dog.monitor('metric alert', query, :options=>options)[1]['id']
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal monitor['query'], query, monitor['query']
-    assert_equal monitor['options']['silenced'], options['silenced'], monitor['options']
-
-    query2 = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200'
-    updated_monitor_id = dog.update_monitor(monitor_id, query2,
-                                :options => options)[1]['id']
-    status, monitor = dog.get_monitor(updated_monitor_id)
-    assert_equal monitor['query'], query2, monitor['query']
-
-    name = 'test_monitors'
-    monitor_id = dog.update_monitor(monitor_id, query2, :name => name,
-        :options=>{'notify_no_data' => true})[1]['id']
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal monitor['name'], name, monitor['name']
-    assert_equal monitor['options']['notify_no_data'], true, monitor['options']
-
-    dog.delete_monitor(monitor_id)
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal status.to_i, 404, status.to_i
-
-    query1 = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100"
-    query2 = "avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 200"
-    query3 = "avg(last_1h):sum:system.net.bytes_rcvd{host:host1} > 200"
-
-    monitor_id1 = dog.monitor('metric alert', query1)[1]['id']
-    monitor_id2 = dog.monitor('metric alert', query2)[1]['id']
-    monitor_id3 = dog.monitor('metric alert', query3)[1]['id']
-    status, monitors = dog.get_all_monitors(:group_states => ['alert', 'warn'])
-    monitor1 = monitors.map{|m| m if m['id'] == monitor_id1}.compact[0]
-    monitor2 = monitors.map{|m| m if m['id'] == monitor_id2}.compact[0]
-    assert_equal monitor1['query'], query1, monitor1['query']
-    assert_equal monitor2['query'], query2, monitor2['query']
-
-    status, monitors = dog.get_all_monitors(:tags => ['host:host1'])
-    monitor3 = monitors.map{|m| m if m['id'] == monitor_id3}.compact[0]
-    assert_equal monitor3['query'], query3, monitor3['query']
-    assert_equal nil, monitors.map{|m| m if m['id'] == monitor_id1}.compact[0]
-    assert_equal nil, monitors.map{|m| m if m['id'] == monitor_id2}.compact[0]
-
-    dog.delete_monitor(monitor_id1)
-    dog.delete_monitor(monitor_id2)
-    dog.delete_monitor(monitor_id3)
-  end
-
-  def test_checks
-    dog = Dogapi::Client.new(@api_key, @app_key)
-
-    query = '"ntp.in_sync".over("role:herc").last(3).count_by_status()'
-    options = {
-        'notify_no_data' => false,
-        'thresholds' => {
-            'ok' => 3,
-            'warning' => 2,
-            'critical' => 1,
-            'no data' => 3
-        }
-    }
-    monitor_id = dog.monitor('service check', query, :options => options)[1]['id']
-    status, monitor = dog.get_monitor(monitor_id, :group_states => ['all'])
-
-    assert_equal monitor['query'], query, monitor['query']
-    assert_equal monitor['options']['notify_no_data'], options['notify_no_data'], monitor['options']
-    assert_equal monitor['options']['thresholds'], options['thresholds'], monitor['options']
-
-    query2 = '"ntp.in_sync".over("role:sobotka").last(3).count_by_status()'
-    monitor_id = dog.update_monitor(monitor_id, query2)[1]['id']
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal monitor['query'], query2, monitor['query']
-
-    dog.delete_monitor(monitor_id)
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal status.to_i, 404, status.to_i
-  end
-
-  def test_monitor_muting
-    dog = Dogapi::Client.new(@api_key, @app_key)
-
-    query = 'avg(last_1h):sum:system.net.bytes_rcvd{host:host0} > 100'
-    monitor_id = dog.monitor('metric alert', query)[1]['id']
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal monitor['query'], query, monitor['query']
-
-    status, dt = dog.mute_monitors()
-    assert_equal dt['active'], true, dt['active']
-    assert_equal dt['scope'], ['*'], dt['scope']
-
-    status, dt = dog.unmute_monitors()
-    assert_equal status.to_i, 204, status.to_i
-
-    # We shouldn't be able to mute a simple alert on a scope.
-    status, _ = dog.mute_monitor(monitor_id, :scope => 'env:staging')
-    assert_equal status.to_i, 400, status.to_i
-
-    query2 = 'avg(last_1h):sum:system.net.bytes_rcvd{*} by {host} > 100'
-    monitor_id = dog.monitor('metric alert', query2)[1]['id']
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal monitor['query'], query2, monitor['query']
-
-    dog.mute_monitor(monitor_id, :scope => 'host:foo')
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal monitor['options']['silenced'], {'host:foo' => nil}, monitor['options']
-
-    dog.unmute_monitor(monitor_id, :scope => 'host:foo')
-    status, monitor = dog.get_monitor(monitor_id)
-    assert_equal monitor['options']['silenced'], {}, monitor['options']
-
-    dog.delete_monitor(monitor_id)
-  end
-
-  def test_downtime
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    start_ts = Time.now.to_i
-    end_ts = start_ts + 1000
-    downtime_id = dog.schedule_downtime('env:staging', :start => start_ts,
-                                        :end => end_ts, :message=>'Message!')[1]['id']
-    status, dt = dog.get_downtime(downtime_id)
-    assert_equal dt['start'], start_ts, dt['start']
-    assert_equal dt['end'], end_ts, dt['end']
-    assert_equal dt['scope'], ['env:staging'], dt['scope']
-    assert_equal dt['message'], 'Message!', dt['messsage']
-
-    dog.update_downtime(downtime_id, :start => start_ts + 1, :end => end_ts + 1,
-                        :scope => 'env:prod', :message => 'New Message!')
-    status, dt = dog.get_downtime(downtime_id)
-    assert_equal dt['start'], start_ts + 1, dt['start']
-    assert_equal dt['end'], end_ts + 1, dt['end']
-    assert_equal dt['scope'], ['env:prod'], dt['scope']
-    assert_equal dt['message'], 'New Message!', dt['messsage']
-
-    dog.cancel_downtime(downtime_id)
-  end
-
-  def test_host_muting
-    dog = Dogapi::Client.new(@api_key, @app_key)
-
-    hostname = 'test.host%d' % rand(10000)
-
-    # Reset test
-    dog.unmute_host(hostname)
-
-    message = "Muting this host for a test."
-    end_ts = Time.now.to_i + 60 * 60
-
-    res_code, res = dog.mute_host(hostname, :end => end_ts, :message => message)
-    assert_equal res_code, "200", res_code
-    assert_equal res["action"], "Muted", res["action"]
-    assert_equal res["hostname"], hostname, res["hostname"]
-    assert_equal res["message"], message, res["message"]
-    assert_equal res["end"], end_ts, res["end"]
-
-    # muting the same host multiple times should fail unless override is true
-    end_ts2 = end_ts + 60 * 15
-    res_code, res = dog.mute_host(hostname, :end => end_ts2)
-    assert_equal res_code, "400", res_code
-
-    res_code, res = dog.mute_host(hostname, :end => end_ts2, :override => true)
-    assert_equal res_code, "200", res_code
-    assert_equal res["action"], "Muted", res["action"]
-    assert_equal res["hostname"], hostname, res["hostname"]
-    assert_equal res["end"], end_ts2, res["end"]
-
-    res_code, res = dog.unmute_host(hostname)
-    assert_equal res_code, "200", res_code
-    assert_equal res["action"], "Unmuted", res["action"]
-    assert_equal res["hostname"], hostname, res["hostname"]
-  end
-
-  def test_service_checks
-    dog = Dogapi::Client.new(@api_key, @app_key)
-    status, response = dog.service_check('app.ok', 'app1', 1)
-    assert_equal status.to_i, 202
-  end
-
-end