efigence-influxdb 0.1.0

data/spec/influxdb/cases/query_cluster_spec.rb

@@ -0,0 +1,65 @@
+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) { {} }
+
+  describe "#create_cluster_admin" do
+    let(:user) { 'adminadmin' }
+    let(:pass) { 'passpass' }
+    let(:query) { "CREATE USER #{user} WITH PASSWORD '#{pass}' WITH ALL PRIVILEGES" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: query}
+      )
+    end
+
+    it "should GET to create a new cluster admin" do
+      expect(subject.create_cluster_admin(user, pass)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#list_cluster_admins" do
+    let(:response) { {"results"=>[{"series"=>[{"columns"=>["user", "admin"], "values"=>[["dbadmin", true], ["foobar", false]]}]}]} }
+    let(:expected_result) { [{"username"=>"dbadmin"}] }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: "SHOW USERS"}
+      ).to_return(:body => JSON.generate(response, :status => 200))
+    end
+
+    it "should GET a list of cluster admins" do
+      expect(subject.list_cluster_admins).to eq(expected_result)
+    end
+  end
+
+  describe "#revoke_cluster_admin_privileges" do
+    let(:user) { 'useruser' }
+    let(:query) { "REVOKE ALL PRIVILEGES FROM #{user}" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: query}
+      )
+    end
+
+    it "should GET to revoke cluster admin privileges from a user" do
+      expect(subject.revoke_cluster_admin_privileges(user)).to be_a(Net::HTTPOK)
+    end
+  end
+end

data/spec/influxdb/cases/query_database_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) { {} }
+
+  describe "#create_database" do
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: "CREATE DATABASE foo"}
+      )
+    end
+
+    it "should GET to create a new database" do
+      expect(subject.create_database("foo")).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#delete_database" do
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: "DROP DATABASE foo"}
+      )
+    end
+
+    it "should GET to remove a database" do
+      expect(subject.delete_database("foo")).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#list_databases" do
+    let(:response) { {"results"=>[{"series"=>[{"name"=>"databases", "columns"=>["name"], "values"=>[["foobar"]]}]}]} }
+    let(:expected_result) { [{"name"=>"foobar"}] }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: "SHOW DATABASES"}
+      ).to_return(:body => JSON.generate(response), :status => 200)
+    end
+
+    it "should GET a list of databases" do
+      expect(subject.list_databases).to eq(expected_result)
+    end
+  end
+end

data/spec/influxdb/cases/query_series_spec.rb

@@ -0,0 +1,50 @@
+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) { {} }
+
+  ### TODO ###
+
+  # describe "DELETE #delete_series" do
+  #   it "removes a series" do
+  #     stub_request(:delete, "http://influxdb.test:9999/db/database/series/foo").with(
+  #       query: { u: "username", p: "password" }
+  #     )
+
+  #     expect(subject.delete_series("foo")).to be_a(Net::HTTPOK)
+  #   end
+  # end
+
+  # describe "GET #list_series" do
+  #   it "returns a list of all series names" do
+  #     data = [
+  #       { "name" => "list_series_result",
+  #         "columns" => %w(time name),
+  #         "points" => [[0, 'a'], [0, 'b']]
+  #       }
+  #     ]
+
+  #     stub_request(:get, "http://influxdb.test:9999/db/database/series").with(
+  #       query: { u: "username", p: "password", q: "list series", time_precision: "s" }
+  #     ).to_return(
+  #       body: JSON.generate(data)
+  #     )
+
+  #     expect(subject.list_series).to eq %w(a b)
+  #   end
+  # end
+end

data/spec/influxdb/cases/query_shard_spec.rb

@@ -0,0 +1,43 @@
+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) { {} }
+
+  ### TODO ###
+
+  # describe "GET #list_shards" do
+  #   it "returns a list of shards" do
+  #     shard_list = { "longTerm" => [], "shortTerm" => [] }
+  #     stub_request(:get, "http://influxdb.test:9999/cluster/shards").with(
+  #       query: { u: "username", p: "password" }
+  #     ).to_return(body: JSON.generate(shard_list, status: 200))
+
+  #     expect(subject.list_shards).to eq shard_list
+  #   end
+  # end
+
+  # describe "DELETE #delete_shard" do
+  #   it "removes shard by id" do
+  #     shard_id = 1
+  #     stub_request(:delete, "http://influxdb.test:9999/cluster/shards/#{shard_id}").with(
+  #       query: { u: "username", p: "password" }
+  #     )
+
+  #     expect(subject.delete_shard(shard_id, [1, 2])).to be_a(Net::HTTPOK)
+  #   end
+  # end
+end

data/spec/influxdb/cases/query_user_spec.rb

@@ -0,0 +1,127 @@
+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) { {} }
+
+  describe "#update user password" do
+    let(:user) { 'useruser' }
+    let(:pass) { 'passpass' }
+    let(:query) { "SET PASSWORD FOR #{user} = '#{pass}'" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: query}
+      )
+    end
+
+    it "should GET to update user password" do
+      expect(subject.update_user_password(user, pass)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#grant_user_privileges" do
+    let(:user) { 'useruser' }
+    let(:perm) { :write }
+    let(:db) { 'foo' }
+    let(:query) { "GRANT #{perm.to_s.upcase} ON #{db} TO #{user}" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: query}
+      )
+    end
+
+    it "should GET to grant privileges for a user on a database" do
+      expect(subject.grant_user_privileges(user, db, perm)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#revoke_user_privileges" do
+    let(:user) { 'useruser' }
+    let(:perm) { :write }
+    let(:db) { 'foo' }
+    let(:query) { "REVOKE #{perm.to_s.upcase} ON #{db} FROM #{user}" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: query}
+      )
+    end
+
+    it "should GET to revoke privileges from a user on a database" do
+      expect(subject.revoke_user_privileges(user, db, perm)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#create_database_user" do
+    let(:user) { 'useruser' }
+    let(:pass) { 'passpass' }
+    let(:db) { 'foo' }
+    let(:query) { "CREATE user #{user} WITH PASSWORD '#{pass}'; GRANT ALL ON #{db} TO #{user}" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: query}
+      )
+    end
+
+    context "without specifying permissions" do
+      it "should GET to create a new database user with all permissions" do
+        expect(subject.create_database_user(db, user, pass)).to be_a(Net::HTTPOK)
+      end
+    end
+
+    context "with passing permission as argument" do
+      let(:permission) { :read }
+      let(:query) { "CREATE user #{user} WITH PASSWORD '#{pass}'; GRANT #{permission.to_s.upcase} ON #{db} TO #{user}" }
+
+      it "should GET to create a new database user with permission set" do
+        expect(subject.create_database_user(db, user, pass, permissions: permission)).to be_a(Net::HTTPOK)
+      end
+    end
+  end
+
+  describe "#delete_user" do
+    let(:user) { 'useruser' }
+    let(:query) { "DROP USER #{user}" }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: query}
+      )
+    end
+
+    it "should GET to delete a user" do
+      expect(subject.delete_user(user)).to be_a(Net::HTTPOK)
+    end
+  end
+
+  describe "#list_users" do
+    let(:response) { {"results"=>[{"series"=>[{"columns"=>["user", "admin"], "values"=>[["dbadmin", true], ["foobar", false]]}]}]} }
+    let(:expected_result) { [{"username"=>"dbadmin", "admin"=>true}, {"username"=>"foobar", "admin"=>false}] }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: {u: "username", p: "password", q: "SHOW USERS"}
+      ).to_return(:body => JSON.generate(response, :status => 200))
+    end
+
+    it "should GET a list of database users" do
+      expect(subject.list_users).to eq(expected_result)
+    end
+  end
+end

data/spec/influxdb/cases/querying_spec.rb

@@ -0,0 +1,159 @@
+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 "#query" do
+
+    context "with single series with multiple points" do
+      let(:response) do
+        {"results"=>[{"series"=>[{"name"=>"cpu", "tags"=>{"region"=>"us"},
+         "columns"=>["time", "temp", "value"],
+         "values"=>[["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]]}]}]}
+      end
+      let(:expected_result) do
+        [{"name"=>"cpu", "tags"=>{"region"=>"us"},
+         "values"=>[{"time"=>"2015-07-07T14:58:37Z", "temp"=>92, "value"=>0.3445},
+         {"time"=>"2015-07-07T14:59:09Z", "temp"=>68, "value"=>0.8787}]}]
+      end
+      let(:query) { 'SELECT * FROM cpu' }
+
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query").with(
+          :query => {:q => query, :u => "username", :p => "password", :precision => 's', :db => database},
+        ).to_return(:body => JSON.generate(response))
+      end
+
+      it "should return array with single hash containing multiple values" do
+        expect(subject.query(query)).to eq(expected_result)
+      end
+    end
+
+    context "with series with different tags" do
+      let(:response) do
+        {"results"=>
+          [{"series"=>
+            [{"name"=>"cpu", "tags"=>{"region"=>"pl"}, "columns"=>["time", "temp", "value"], "values"=>[["2015-07-07T15:13:04Z", 34, 0.343443]]},
+             {"name"=>"cpu", "tags"=>{"region"=>"us"}, "columns"=>["time", "temp", "value"], "values"=>[["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]]}]}]}
+      end
+      let(:expected_result) do
+        [{"name"=>"cpu", "tags"=>{"region"=>"pl"},
+         "values"=>[{"time"=>"2015-07-07T15:13:04Z", "temp"=>34, "value"=>0.343443}]},
+         {"name"=>"cpu", "tags"=>{"region"=>"us"},
+         "values"=>[{"time"=>"2015-07-07T14:58:37Z", "temp"=>92, "value"=>0.3445},
+          {"time"=>"2015-07-07T14:59:09Z", "temp"=>68, "value"=>0.8787}]}]
+      end
+      let(:query) { 'SELECT * FROM cpu' }
+
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query").with(
+          :query => {:q => query, :u => "username", :p => "password", :precision => 's', :db => database},
+        ).to_return(:body => JSON.generate(response))
+      end
+
+      it "should return array with 2 elements grouped by tags" do
+        expect(subject.query(query)).to eq(expected_result)
+      end
+    end
+
+    context "with multiple series with different tags" do
+      let(:response) do
+        {"results"=>
+          [{"series"=>
+            [{"name"=>"access_times.service_1", "tags"=>{"code"=>"200", "result"=>"failure", "status"=>"OK"}, "columns"=>["time", "value"], "values"=>[["2015-07-08T07:15:22Z", 327]]},
+            {"name"=>"access_times.service_1", "tags"=>{"code"=>"500", "result"=>"failure", "status"=>"Internal Server Error"}, "columns"=>["time", "value"], "values"=>[["2015-07-08T06:15:22Z", 873]]},
+            {"name"=>"access_times.service_2", "tags"=>{"code"=>"200", "result"=>"failure", "status"=>"OK"}, "columns"=>["time", "value"], "values"=>[["2015-07-08T07:15:22Z", 943]]},
+            {"name"=>"access_times.service_2", "tags"=>{"code"=>"500", "result"=>"failure", "status"=>"Internal Server Error"}, "columns"=>["time", "value"], "values"=>[["2015-07-08T06:15:22Z", 606]]}]}]}
+      end
+      let(:expected_result) do
+        [{"name"=>"access_times.service_1", "tags"=>{"code"=>"200", "result"=>"failure", "status"=>"OK"}, "values"=>[{"time"=>"2015-07-08T07:15:22Z", "value"=>327}]},
+         {"name"=>"access_times.service_1", "tags"=>{"code"=>"500", "result"=>"failure", "status"=>"Internal Server Error"}, "values"=>[{"time"=>"2015-07-08T06:15:22Z", "value"=>873}]},
+         {"name"=>"access_times.service_2", "tags"=>{"code"=>"200", "result"=>"failure", "status"=>"OK"}, "values"=>[{"time"=>"2015-07-08T07:15:22Z", "value"=>943}]},
+         {"name"=>"access_times.service_2", "tags"=>{"code"=>"500", "result"=>"failure", "status"=>"Internal Server Error"}, "values"=>[{"time"=>"2015-07-08T06:15:22Z", "value"=>606}]}]
+      end
+      let(:query) { "SELECT * FROM /access_times.*/" }
+
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query").with(
+          :query => {:q => query, :u => "username", :p => "password", :precision => 's', :db => database},
+        ).to_return(:body => JSON.generate(response))
+      end
+
+      it "should return array with 4 elements grouped by name and tags" do
+        expect(subject.query(query)).to eq(expected_result)
+      end
+    end
+
+    context "with multiple series for explicit value only" do
+      let(:response) do
+        {"results"=>
+          [{"series"=>
+             [{"name"=>"access_times.service_1", "columns"=>["time", "value"], "values"=>[["2015-07-08T06:15:22Z", 873], ["2015-07-08T07:15:22Z", 327]]},
+              {"name"=>"access_times.service_2", "columns"=>["time", "value"], "values"=>[["2015-07-08T06:15:22Z", 606], ["2015-07-08T07:15:22Z", 943]]}]}]}
+      end
+      let(:expected_result) do
+        [{"name"=>"access_times.service_1", "tags"=>nil, "values"=>[{"time"=>"2015-07-08T06:15:22Z", "value"=>873}, {"time"=>"2015-07-08T07:15:22Z", "value"=>327}]},
+         {"name"=>"access_times.service_2", "tags"=>nil, "values"=>[{"time"=>"2015-07-08T06:15:22Z", "value"=>606}, {"time"=>"2015-07-08T07:15:22Z", "value"=>943}]}]
+      end
+      let(:query) { "SELECT value FROM /access_times.*/" }
+
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query").with(
+          :query => {:q => query, :u => "username", :p => "password", :precision => 's', :db => database},
+        ).to_return(:body => JSON.generate(response))
+      end
+
+      it "should return array with 2 elements grouped by name only and no tags" do
+        expect(subject.query(query)).to eq(expected_result)
+      end
+    end
+
+    context "with a block" do
+      let(:response) do
+        {"results"=>
+          [{"series"=>
+            [{"name"=>"cpu", "tags"=>{"region"=>"pl"}, "columns"=>["time", "temp", "value"], "values"=>[["2015-07-07T15:13:04Z", 34, 0.343443]]},
+             {"name"=>"cpu", "tags"=>{"region"=>"us"}, "columns"=>["time", "temp", "value"], "values"=>[["2015-07-07T14:58:37Z", 92, 0.3445], ["2015-07-07T14:59:09Z", 68, 0.8787]]}]}]}
+      end
+
+      let(:expected_result) do
+        [{"name"=>"cpu", "tags"=>{"region"=>"pl"},
+         "values"=>[{"time"=>"2015-07-07T15:13:04Z", "temp"=>34, "value"=>0.343443}]},
+         {"name"=>"cpu", "tags"=>{"region"=>"us"},
+         "values"=>[{"time"=>"2015-07-07T14:58:37Z", "temp"=>92, "value"=>0.3445},
+          {"time"=>"2015-07-07T14:59:09Z", "temp"=>68, "value"=>0.8787}]}]
+      end
+      let(:query) { 'SELECT * FROM cpu' }
+
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query").with(
+          :query => {:q => query, :u => "username", :p => "password", :precision => 's', :db => database},
+        ).to_return(:body => JSON.generate(response))
+      end
+
+      it "should accept a block and yield name, tags and points" do
+        results = []
+        subject.query(query) do |name, tags, points|
+          results << {'name' => name, 'tags' => tags, 'values' => points}
+        end
+        expect(results).to eq(expected_result)
+      end
+    end
+  end
+
+end