influxdb 0.1.9 → 0.2.0

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_retention_policy_spec.rb

@@ -0,0 +1,84 @@
+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 "#list_retention_policies" do
+    let(:response) { { "results" => [{ "series" => [{ "columns" => %w(name duration replicaN default), "values" => [["default", "0", 1, true], ["another", "1", 2, false]] }] }] } }
+    let(:expected_result) { [{ "name" => "default", "duration" => "0", "replicaN" => 1, "default" => true }, { "name" => "another", "duration" => "1", "replicaN" => 2, "default" => false }] }
+
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: "SHOW RETENTION POLICIES \"database\"" }
+      ).to_return(body: JSON.generate(response), status: 200)
+    end
+
+    it "should GET a list of retention policies" do
+      expect(subject.list_retention_policies('database')).to eq(expected_result)
+    end
+  end
+
+  describe "#create_retention_policy" do
+    context "default" do
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query")
+          .with(
+            query:
+              {
+                u: "username",
+                p: "password",
+                q: "CREATE RETENTION POLICY \"1h.cpu\" ON foo DURATION 1h REPLICATION 2 DEFAULT"
+              }
+          )
+      end
+
+      it "should GET to create a new database" do
+        expect(subject.create_retention_policy('1h.cpu', 'foo', '1h', 2, true)).to be_a(Net::HTTPOK)
+      end
+    end
+
+    context "non-default" do
+      before do
+        stub_request(:get, "http://influxdb.test:9999/query")
+          .with(
+            query:
+              {
+                u: "username",
+                p: "password",
+                q: "CREATE RETENTION POLICY \"1h.cpu\" ON foo DURATION 1h REPLICATION 2"
+              }
+          )
+      end
+
+      it "should GET to create a new database" do
+        expect(subject.create_retention_policy('1h.cpu', 'foo', '1h', 2)).to be_a(Net::HTTPOK)
+      end
+    end
+  end
+
+  describe "#delete_retention_policy" do
+    before do
+      stub_request(:get, "http://influxdb.test:9999/query").with(
+        query: { u: "username", p: "password", q: "DROP RETENTION POLICY \"1h.cpu\" ON foo" }
+      )
+    end
+
+    it "should GET to remove a database" do
+      expect(subject.delete_retention_policy('1h.cpu', 'foo')).to be_a(Net::HTTPOK)
+    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_space_spec.rb

@@ -0,0 +1,105 @@
+# TODO: support 0.9.x
+
+# 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(:url) { "http://influxdb.test:9999/cluster/shard_spaces" }
+#   let(:req_query) { { u: "username", p: "password" } }
+#   let(:req_body) { nil }
+#   let(:request_params) { { query: req_query, body: req_body } }
+#   let(:response) { { body: JSON.generate(shard_spaces), status: 200 } }
+#   let(:shard_spaces)   { [subject.default_shard_space_options.merge("database" => "foo")] }
+
+#   context "GET methods" do
+#     before { stub_request(:get, url).with(request_params).to_return(response) }
+
+#     describe "GET #list_shard_spaces" do
+#       it 'returns OK' do
+#         expect(subject.list_shard_spaces).to eq shard_spaces
+#       end
+#     end
+
+#     describe "GET #shard_space_info" do
+#       context "non-empty list" do
+#         it "returns shard space info" do
+#           expect(subject.shard_space_info('foo', 'default')).to eq shard_spaces.first
+#         end
+#       end
+
+#       context "returns an empty list" do
+#         let(:shard_spaces) { [] }
+
+#         it "returns no shard space" do
+#           expect(subject.shard_space_info('foo', 'default')).to be_nil
+#         end
+#       end
+#     end
+#   end
+
+#   describe "POST #create_shard_space" do
+#     let(:url) { "http://influxdb.test:9999/cluster/shard_spaces/foo" }
+#     let(:req_body) { subject.default_shard_space_options }
+#     let(:response) { { status: 200 } }
+
+#     before { stub_request(:post, url).with(request_params).to_return(response) }
+
+#     it 'returns OK' do
+#       expect(subject.create_shard_space("foo", subject.default_shard_space_options))
+#         .to be_a(Net::HTTPOK)
+#     end
+#   end
+
+#   describe "DELETE #delete_shard_space" do
+#     let(:url) { "http://influxdb.test:9999/cluster/shard_spaces/foo/default" }
+#     let(:response) { { status: 200 } }
+#     before { stub_request(:delete, url).with(request_params).to_return(response) }
+
+#     it 'returns OK' do
+#       expect(subject.delete_shard_space("foo", "default")).to be_a(Net::HTTPOK)
+#     end
+#   end
+
+#   describe "#update_shard_space" do
+#     let(:post_url) { "http://influxdb.test:9999/cluster/shard_spaces/foo/default" }
+#     let(:post_request_params) do
+#       {
+#         query: req_query,
+#         body:  subject.default_shard_space_options.merge("shardDuration" => "30d")
+#       }
+#     end
+
+#     it 'gets the shard space and updates the shard space' do
+#       stub_request(:get, url).with(request_params).to_return(response)
+#       stub_request(:post, post_url).with(post_request_params)
+
+#       expect(subject.update_shard_space("foo", "default", "shardDuration" => "30d")).to be_a(Net::HTTPOK)
+#     end
+#   end
+
+#   describe "POST #configure_database" do
+#     let(:url) { "http://influxdb.test:9999/cluster/database_configs/foo" }
+#     let(:req_body) { subject.default_database_configuration }
+
+#     before { stub_request(:post, url).with(request_params) }
+
+#     it "returns OK" do
+#       expect(subject.configure_database("foo")).to be_a(Net::HTTPOK)
+#     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" => %w(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