efigence-influxdb 0.1.0

data/spec/influxdb/cases/retry_requests_spec.rb

@@ -0,0 +1,97 @@
+require "spec_helper"
+require "json"
+
+describe InfluxDB::Client do
+  let(:client) do
+    described_class.new(
+      "database",
+      {
+        host: "influxdb.test",
+        port: 9999,
+        username: "username",
+        password: "password",
+        time_precision: "s"
+      }.merge(args)
+    )
+  end
+
+  let(:args) { {} }
+
+  let(:database) { client.config.database }
+
+  describe "retrying requests" do
+
+    let(:series) { "cpu" }
+    let(:data) do
+      { tags: { region: 'us', host: 'server_1' },
+        values: { temp: 88,  value: 54 } }
+    end
+    let(:body) do
+      InfluxDB::PointValue.new(data.merge(series: series)).dump
+    end
+
+    subject { client.write_point(series, data) }
+
+    before do
+      allow(client).to receive(:log)
+      stub_request(:post, "http://influxdb.test:9999/write").with(
+        :query => {:u => "username", :p => "password", :precision => 's', :db => database},
+        :headers => {"Content-Type" => "application/octet-stream"},
+        :body => body
+      ).to_raise(Timeout::Error)
+    end
+
+    it "raises when stopped" do
+      client.stop!
+      expect(client).not_to receive(:sleep)
+      expect { subject }.to raise_error(Timeout::Error)
+    end
+
+    context "when retry is 0" do
+      let(:args) { { retry: 0 } }
+      it "raise error directly" do
+        expect(client).not_to receive(:sleep)
+        expect { subject }.to raise_error(Timeout::Error)
+      end
+    end
+
+    context "when retry is 'n'" do
+      let(:args) { { retry: 3 } }
+
+      it "raise error after 'n' attemps" do
+        expect(client).to receive(:sleep).exactly(3).times
+        expect { subject }.to raise_error(Timeout::Error)
+      end
+    end
+
+    context "when retry is -1" do
+      let(:args) { { retry: -1 } }
+      before do
+        stub_request(:post, "http://influxdb.test:9999/write").with(
+          :query => {:u => "username", :p => "password", :precision => 's', :db => database},
+          :headers => {"Content-Type" => "application/octet-stream"},
+          :body => body
+        ).to_raise(Timeout::Error).then
+          .to_raise(Timeout::Error).then
+          .to_raise(Timeout::Error).then
+          .to_raise(Timeout::Error).then
+          .to_return(:status => 200)
+      end
+
+      it "keep trying until get the connection" do
+        expect(client).to receive(:sleep).exactly(4).times
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    it "raise an exception if the server didn't return 200" do
+      stub_request(:post, "http://influxdb.test:9999/write").with(
+        :query => {:u => "username", :p => "password", :precision => 's', :db => database},
+        :headers => {"Content-Type" => "application/octet-stream"},
+        :body => body
+      ).to_return(:status => 401)
+
+      expect { client.write_point(series, data) }.to raise_error
+    end
+  end
+end

data/spec/influxdb/cases/udp_client_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe InfluxDB::Client do
+  let(:client) { described_class.new(udp: { host: "localhost", port: 44_444 }) }
+
+  specify { expect(client.writer).to be_a(InfluxDB::Writer::UDP) }
+
+  describe "#write" do
+    let(:message) { "responses,region=eu value=5" }
+
+    it "sends a UPD packet" do
+      s = UDPSocket.new
+      s.bind("localhost", 44_444)
+
+      client.write_point("responses", values: {value: 5}, tags: {region: 'eu'})
+
+      rec_message = s.recvfrom(30).first
+      expect(rec_message).to eq message
+    end
+  end
+end

data/spec/influxdb/cases/write_points_spec.rb

@@ -0,0 +1,141 @@
+require "spec_helper"
+require "json"
+
+describe InfluxDB::Client do
+  let(:subject) do
+    described_class.new(
+      "database",
+      {
+        host: "influxdb.test",
+        port: 9999,
+        username: "username",
+        password: "password",
+        time_precision: "s"
+      }.merge(args)
+    )
+  end
+
+  let(:args) { {} }
+
+  let(:database) { subject.config.database }
+
+  describe "#write_point" do
+    let(:series) { "cpu" }
+    let(:data) do
+      { tags: { region: 'us', host: 'server_1' },
+        values: { temp: 88,  value: 54 } }
+    end
+    let(:body) do
+      InfluxDB::PointValue.new(data.merge(series: series)).dump
+    end
+
+    before do
+      stub_request(:post, "http://influxdb.test:9999/write").with(
+        :query => {:u => "username", :p => "password", :precision => 's', :db => database},
+        :headers => {"Content-Type" => "application/octet-stream"},
+        :body => body
+      )
+    end
+
+    it "should POST to add single point" do
+      expect(subject.write_point(series, data)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#write_points" do
+
+    context "with multiple series" do
+      let(:data) do
+        [{
+          series: 'cpu',
+          tags: {  region: 'us', host: 'server_1' },
+          values: { temp: 88, value: 54 }
+        },
+        {
+          series: 'gpu',
+          tags: { region: 'uk',  host: 'server_5'},
+          values: { value: 0.5435345}
+        }]
+      end
+      let(:body) do
+        data.map do |point|
+          InfluxDB::PointValue.new(point).dump
+        end.join("\n")
+      end
+
+      before do
+        stub_request(:post, "http://influxdb.test:9999/write").with(
+          :query => {:u => "username", :p => "password", :precision => 's', :db => database},
+          :headers => {"Content-Type" => "application/octet-stream"},
+          :body => body
+      )
+      end
+
+      it "should POST multiple points" do
+        expect(subject.write_points(data)).to be_a(Net::HTTPOK)
+      end
+    end
+
+    context "with no tags" do
+      let(:data) do
+        [{
+          series: 'cpu',
+          values: { temp: 88,  value: 54 }
+        },
+        {
+          series: 'gpu',
+          values: { value: 0.5435345 }
+        }]
+      end
+      let(:body) do
+        data.map do |point|
+          InfluxDB::PointValue.new(point).dump
+        end.join("\n")
+      end
+
+      before do
+        stub_request(:post, "http://influxdb.test:9999/write").with(
+          :query => {:u => "username", :p => "password", :precision => 's', :db => database},
+          :headers => {"Content-Type" => "application/octet-stream"},
+          :body => body
+        )
+      end
+
+      it "should POST multiple points" do
+        expect(subject.write_points(data)).to be_a(Net::HTTPOK)
+      end
+    end
+
+    context "with time precision set to milisceconds" do
+      let(:data) do
+        [{
+          series: 'cpu',
+          values: { temp: 88,  value: 54 },
+          timestamp: (Time.now.to_f * 1000).to_i
+        },
+        {
+          series: 'gpu',
+          values: { value: 0.5435345 },
+          timestamp: (Time.now.to_f * 1000).to_i
+        }]
+      end
+
+      let(:body) do
+        data.map do |point|
+          InfluxDB::PointValue.new(point).dump
+        end.join("\n")
+      end
+
+      before do
+        stub_request(:post, "http://influxdb.test:9999/write").with(
+          :query => {:u => "username", :p => "password", :precision => 'm', :db => database},
+          :headers => {"Content-Type" => "application/octet-stream"},
+          :body => body
+        )
+      end
+      it "should POST multiple points" do
+        expect(subject.write_points(data, 'm')).to be_a(Net::HTTPOK)
+      end
+    end
+  end
+end

data/spec/influxdb/client_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+require "json"
+
+describe InfluxDB::Client do
+  let(:subject) do
+    described_class.new(
+      "database",
+      {
+        host: "influxdb.test",
+        port: 9999,
+        username: "username",
+        password: "password",
+        time_precision: "s"
+      }.merge(args)
+    )
+  end
+
+  let(:args) { {} }
+
+  specify { is_expected.not_to be_stopped }
+
+  context "with basic auth" do
+    let(:args) { { auth_method: 'basic_auth' } }
+
+    let(:stub_url) { "http://username:password@influxdb.test:9999/" }
+    let(:url) { subject.send(:full_url, '/') }
+
+    it "GET" do
+      stub_request(:get, stub_url).to_return(body: '[]')
+      expect(subject.get(url, parse: true)).to eq []
+    end
+
+    it "POST" do
+      stub_request(:post, stub_url)
+      expect(subject.post(url, {})).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#full_url" do
+    it "returns String" do
+      expect(subject.send(:full_url, "/unknown")).to be_a String
+    end
+
+    it "escapes params" do
+      url = subject.send(:full_url, "/unknown", value: ' !@#$%^&*()/\\_+-=?|`~')
+      expect(url).to include("value=+%21%40%23%24%25%5E%26%2A%28%29%2F%5C_%2B-%3D%3F%7C%60%7E")
+    end
+  end
+
+  describe "GET #ping" do
+    it "returns OK" do
+      stub_request(:get, "http://influxdb.test:9999/ping")
+        .to_return(status: 204)
+
+      expect(subject.ping).to be_a(Net::HTTPNoContent)
+    end
+  end
+end

data/spec/influxdb/config_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe InfluxDB::Config do
+  let(:conf) do
+    InfluxDB::Client.new(*args).config
+  end
+
+  let(:args) { {} }
+
+  context "with no parameters specified" do
+    specify { expect(conf.database).to be_nil }
+    specify { expect(conf.hosts).to eq ["localhost"] }
+    specify { expect(conf.port).to eq 8086 }
+    specify { expect(conf.username).to eq "root" }
+    specify { expect(conf.password).to eq "root" }
+    specify { expect(conf.use_ssl).to be_falsey }
+    specify { expect(conf.time_precision).to eq "s" }
+    specify { expect(conf.auth_method).to eq "params" }
+    specify { expect(conf.denormalize).to be_truthy }
+    specify { expect(conf).not_to be_udp }
+    specify { expect(conf).not_to be_async }
+  end
+
+  context "with no database specified" do
+    let(:args) do
+      [{
+        host: "host",
+        port: "port",
+        username: "username",
+        password: "password",
+        time_precision: "m"
+      }]
+    end
+
+    specify { expect(conf.database).to be_nil }
+    specify { expect(conf.hosts).to eq ["host"] }
+    specify { expect(conf.port).to eq "port" }
+    specify { expect(conf.username).to eq "username" }
+    specify { expect(conf.password).to eq "password" }
+    specify { expect(conf.time_precision).to eq "m" }
+  end
+
+  context "with both a database and options specified" do
+    let(:args) do
+      [
+        "database",
+        host: "host",
+        port: "port",
+        username: "username",
+        password: "password",
+        time_precision: "m"
+      ]
+    end
+
+    specify { expect(conf.database).to eq "database" }
+    specify { expect(conf.hosts).to eq ["host"] }
+    specify { expect(conf.port).to eq "port" }
+    specify { expect(conf.username).to eq "username" }
+    specify { expect(conf.password).to eq "password" }
+    specify { expect(conf.time_precision).to eq "m" }
+  end
+
+  context "with ssl option specified" do
+    let(:args) { [{ use_ssl: true }] }
+
+    specify { expect(conf.database).to be_nil }
+    specify { expect(conf.hosts).to eq ["localhost"] }
+    specify { expect(conf.port).to eq 8086 }
+    specify { expect(conf.username).to eq "root" }
+    specify { expect(conf.password).to eq "root" }
+    specify { expect(conf.use_ssl).to be_truthy }
+  end
+
+  context "with multiple hosts specified" do
+    let(:args) { [{ hosts: ["1.1.1.1", "2.2.2.2"] }] }
+
+    specify { expect(conf.database).to be_nil }
+    specify { expect(conf.port).to eq 8086 }
+    specify { expect(conf.username).to eq "root" }
+    specify { expect(conf.password).to eq "root" }
+    specify { expect(conf.hosts).to eq ["1.1.1.1", "2.2.2.2"] }
+  end
+
+  context "with auth_method basic auth specified" do
+    let(:args) { [{ auth_method: 'basic_auth' }] }
+
+    specify { expect(conf.database).to be_nil }
+    specify { expect(conf.hosts).to eq ["localhost"] }
+    specify { expect(conf.port).to eq 8086 }
+    specify { expect(conf.username).to eq "root" }
+    specify { expect(conf.password).to eq "root" }
+    specify { expect(conf.auth_method).to eq "basic_auth" }
+  end
+
+  context "with udp specified with params" do
+    let(:args) { [{ udp: { host: 'localhost', port: 4444 } }] }
+
+    specify { expect(conf).to be_udp }
+  end
+
+  context "with udp specified as true" do
+    let(:args) { [{ udp: true }] }
+
+    specify { expect(conf).to be_udp }
+  end
+
+  context "with async specified with params" do
+    let(:args) { [{ async: { max_queue: 20_000 } }] }
+
+    specify { expect(conf).to be_async }
+  end
+
+  context "with async specified as true" do
+    let(:args) { [{ async: true }] }
+
+    specify { expect(conf).to be_async }
+  end
+end

data/spec/influxdb/logging_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'logger'
+
+describe InfluxDB::Logging do
+  class LoggerTest # :nodoc:
+    include InfluxDB::Logging
+
+    def write_to_log(level, message)
+      log(level, message)
+    end
+  end
+
+  before { @old_logger = InfluxDB::Logging.logger }
+  after { InfluxDB::Logging.logger = @old_logger }
+
+  it "has a default logger" do
+    expect(InfluxDB::Logging.logger).to be_a(Logger)
+  end
+
+  it "allows setting of a logger" do
+    new_logger = Logger.new(STDOUT)
+    InfluxDB::Logging.logger = new_logger
+    expect(InfluxDB::Logging.logger).to eq(new_logger)
+  end
+
+  it "allows disabling of a logger" do
+    InfluxDB::Logging.logger = false
+    expect(InfluxDB::Logging.logger).to eql false
+  end
+
+  context "when logging is disabled" do
+    subject { LoggerTest.new }
+    it "does not log" do
+      InfluxDB::Logging.logger = false
+      expect(InfluxDB::Logging.logger).not_to receive(:debug)
+      subject.write_to_log(:debug, 'test')
+    end
+  end
+
+  context "when included in classes" do
+    subject { LoggerTest.new }
+
+    it "logs" do
+      expect(InfluxDB::Logging.logger).to receive(:debug).with(an_instance_of(String)).once
+      subject.write_to_log(:debug, 'test')
+    end
+  end
+end