influxdb-api 0.0.2 → 0.0.3

data/spec/intergrations/databases_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe 'databases', integration: true do
+  let(:config){ Influxdb::Api::Configuration.new }
+  let(:client){ Influxdb::Api::Client.new(config) }
+
+  subject{ client.databases }
+
+  before do
+    subject.all.each{|db| subject.delete(db['name']) }
+  end
+
+  after do
+    subject.all.each{|db| subject.delete(db['name']) }
+  end
+
+  describe '.all' do
+    context 'when there is none database' do
+      it 'returns empty array' do
+        expect(subject.all).to eq([])
+      end
+    end
+
+    context 'when there are some databases' do
+      before do
+        subject.create('db_name1')
+        subject.create('db_name2')
+      end
+
+      it 'returns the list of databases' do
+        expect(subject.all).to match_array([{ 'name' => 'db_name1' }, { 'name' => 'db_name2' }])
+      end
+    end
+  end
+
+  describe '.create' do
+    it 'creates a new db with given name' do
+      subject.create('db_name')
+      expect(subject.all.include?({ 'name' => 'db_name' })).to be_truthy
+    end
+
+    context 'when there is db with the same name' do
+      before{ subject.create('db_name') }
+
+      it 'raises error' do
+        expect{ subject.create('db_name') }.to raise_error(
+          Influxdb::Api::Client::Errors::Conflict, '[409] database db_name exists'
+        )
+      end
+    end
+  end
+
+  describe '.delete' do
+    context 'for unexisted db' do
+      it 'returns false' do
+        expect(subject.delete('db_name')).to be_falsy
+      end
+    end
+
+    context 'for existed db' do
+      before{ subject.create('db_name') }
+
+      it 'removes db and returns true' do
+        expect(subject.delete('db_name')).to be_truthy
+      end
+    end
+  end
+end

data/spec/intergrations/series_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe 'series', integration: true do
+  let(:config){ Influxdb::Api::Configuration.new }
+  let(:client){ Influxdb::Api::Client.new(config) }
+
+  subject{ client.databases('db_name').series }
+
+  before do
+    client.databases.create('db_name')
+    subject.all.each{|name| subject.delete(name) }
+  end
+
+  after{ client.databases.delete('db_name') }
+
+  def series_data(name)
+    name = name.to_s
+    subject.execute('select * from ' + name)[name] || []
+  end
+
+  describe '.all' do
+    context 'when there is none series' do
+      it 'returns empty array' do
+        expect(subject.all).to eq([])
+      end
+    end
+
+    context 'when there are some series' do
+      before do
+        subject.write('name1', v: 1)
+        subject.write('name2', v: 2)
+      end
+
+      it 'returns the list of series' do
+        expect(subject.all).to match_array(['name1', 'name2'])
+      end
+    end
+  end
+
+  describe '.write' do
+    it 'writes row into the series' do
+      subject.write(:name, v: 1)
+      expect(series_data(:name).size).to eq(1)
+    end
+
+    it 'writes multiple rows into the series' do
+      subject.write(:name, [{ v: 1 }, { v: 2 }])
+      expect(series_data(:name).size).to eq(2)
+    end
+
+    it 'writes multiple rows into multiple series' do
+      subject.write(name1: [{ v: 1 }], name2: [{ v: 2 }])
+
+      expect(series_data(:name1).size).to eq(1)
+      expect(series_data(:name2).size).to eq(1)
+    end
+  end
+
+  describe '.execute' do
+     context 'when series does not exist', version: '<=0.8.3' do
+      it 'returns empty Hash' do
+        expect(subject.execute('SELECT * FROM name')).to eq({})
+      end
+    end
+
+     context 'when series does not exist', version: '>0.8.3' do
+      it 'raises error' do
+        expect{ subject.execute('SELECT * FROM name') }.to raise_error(
+          Influxdb::Api::Client::Errors::BadRequest, "[400] Couldn't find series: name"
+        )
+      end
+    end
+
+    context 'when series exists', time_freeze: '16.09.2014 00:00:00 +0700' do
+      before{ subject.write(:name, v: 1) }
+
+      let(:result){ subject.execute('SELECT * FROM name') }
+
+      it 'returns result of the query' do
+        expect(result).to be_instance_of(Hash)
+        expect(result['name']).to be_instance_of(Array)
+        expect(result['name'].size).to eq(1)
+        expect(result['name'][0]).to be_instance_of(Hash)
+        expect(result['name'][0]['v']).to eq(1)
+      end
+    end
+  end
+
+  describe '.delete' do
+    context 'for unexisted series' do
+      it 'returns true' do
+        expect(subject.delete('name')).to be_truthy
+      end
+    end
+
+    context 'for existed db' do
+      before{ subject.write(:name, v: 1) }
+
+      it 'removes db and returns true' do
+        expect(subject.delete('name')).to be_truthy
+      end
+    end
+  end
+end

data/spec/intergrations/servers_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe 'servers', integration: true do
+  let(:config){ Influxdb::Api::Configuration.new }
+  let(:client){ Influxdb::Api::Client.new(config) }
+  let(:result){ subject.all }
+
+  subject{ client.servers }
+
+  before{ client.databases.create('db_name') }
+  after{ client.databases.delete('db_name') }
+
+  describe '.all' do
+    it 'returns list of shards', version: '<=0.7.3' do
+      expect(result).to be_instance_of(Array)
+      expect(result[0]).to include('id', 'protobufConnectString')
+    end
+
+    it 'returns list of shards', version: '0.7.3-0.8.4' do
+      expect(result).to be_instance_of(Array)
+      expect(result[0]).to include(
+        'id', 'isLeader', 'isUp', 'leaderRaftConnectString', 'leaderRaftName', 'protobufConnectString',
+        'raftConnectionString', 'raftName', 'state', 'stateName'
+      )
+    end
+
+    it 'returns list of shards', version: '>0.8.3' do
+      expect(result).to be_instance_of(Array)
+      expect(result[0]).to include(
+        'id', 'isLeader', 'isUp', 'leaderRaftConnectString', 'leaderRaftName', 'protobufConnectString',
+        'raftConnectionString', 'raftName'
+      )
+    end
+  end
+end

data/spec/intergrations/shard_spaces_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe 'shard_spaces', version: '>0.7.3', integration: true do
+  let(:config){ Influxdb::Api::Configuration.new }
+  let(:client){ Influxdb::Api::Client.new(config) }
+  let(:shard_space){ {
+    'name' => 'default',
+    'database' => 'db_name',
+    'retentionPolicy' => 'inf',
+    'shardDuration' => '7d',
+    'regex' => '/.*/',
+    'replicationFactor' => 1,
+    'split' => 1
+  } }
+
+  subject{ client.databases('db_name').shard_spaces }
+
+  before{ client.databases.create('db_name') }
+  after{ client.databases.delete('db_name') }
+
+  describe '.all' do
+    context 'when database just has been created' do
+      it 'returns empty list' do
+        expect(subject.all).to eq([])
+      end
+    end
+
+    context 'when there are some shard spaces' do
+      before{ client.databases('db_name').series.write(:name, v: 1) }
+
+      it 'returns list of shard spaces' do
+        expect(subject.all).to eq([shard_space])
+      end
+    end
+  end
+
+  describe '.create' do
+    it 'creates shard space' do
+      subject.create(shard_space)
+      expect(subject.all).to eq([shard_space])
+    end
+
+    context 'when there is already the same shard space' do
+      before{ subject.create(shard_space) }
+
+      it 'raises error' do
+        expect{ subject.create(shard_space) }.to raise_error(
+          Influxdb::Api::Client::Errors::BadRequest, '[400] Shard space default exists for db db_name'
+        )
+      end
+    end
+  end
+
+  describe '.update' do
+    let(:new_attributes){ {
+      retentionPolicy: '30d',
+      shardDuration: '15d',
+      regex: '/.*/',
+      replicationFactor: 1,
+      split: 1
+    } }
+
+    let(:unacceptable_attributes){ {
+      retentionPolicy: '30d',
+      shardDuration: '15d',
+      regex: '/.*/',
+      replicationFactor: 1,
+      split: 1,
+      someuUnacceptableAttribute: 'lalala'
+    } }
+
+    before{ subject.create(shard_space) }
+
+    it 'updates attributes of shard space' do
+      subject.update('default', new_attributes)
+      expect(subject.all).to eq([{
+        'name' => 'default',
+        'database' => 'db_name',
+        'retentionPolicy' => '30d',
+        'shardDuration' => '15d',
+        'regex' => '/.*/',
+        'replicationFactor' => 1,
+        'split' => 1
+      }])
+    end
+
+    context 'when same shard space does not exist' do
+      it 'raises error' do
+        expect{ subject.update('unexisted_name', new_attributes) }.to raise_error(
+          Influxdb::Api::Client::Errors::NotAcceptable, "[406] Can't update a shard space that doesn't exist"
+        )
+      end
+    end
+
+    context 'with unacceptable attributes' do
+      it 'updates only valid attributes' do
+        subject.update('default', unacceptable_attributes)
+        expect(subject.all).to eq([{
+          'name' => 'default',
+          'database' => 'db_name',
+          'retentionPolicy' => '30d',
+          'shardDuration' => '15d',
+          'regex' => '/.*/',
+          'replicationFactor' => 1,
+          'split' => 1
+        }])
+      end
+    end
+  end
+
+  describe '.delete' do
+    context 'when shard space exists' do
+      before{ subject.create(shard_space) }
+
+      it 'deletes shard space' do
+        expect{ subject.delete('default') }.to change{ subject.all.size }.from(1).to(0)
+      end
+    end
+
+    context 'when shard space does not exist' do
+      it 'does nothing' do
+        expect{ subject.delete('unexisted_name') }.not_to change{ subject.all.size }
+      end
+    end
+  end
+end

data/spec/intergrations/shards_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe 'shards', integration: true do
+  let(:config){ Influxdb::Api::Configuration.new }
+  let(:client){ Influxdb::Api::Client.new(config) }
+  let(:result){ subject.all }
+
+  subject{ client.shards }
+
+  before do
+    client.databases.create('db_name')
+    client.databases('db_name').series.write(:name, v: 1)
+  end
+
+  after{ client.databases.delete('db_name') }
+
+  describe '.all' do
+    it 'returns list of shards', version: '>0.7.3' do
+      expect(result).to be_instance_of(Array)
+      expect(result).not_to be_empty
+    end
+
+    it 'returns list of shards', version: '<=0.7.3' do
+      expect(result).to be_instance_of(Hash)
+      expect(result).not_to be_empty
+    end
+  end
+
+  describe '.create', time_freeze: Time.now, version: '<=0.7.3' do
+    let(:attributes){ {
+      startTime: Time.now,
+      endTime: Time.now.to_i + 86400,
+      spaceName: 'default',
+      shards: [{ serverIds: [1] }],
+      database: 'db_name'
+    } }
+    let(:shard){ result['shortTerm'].sort_by{|v| v['id'] }.last }
+
+    it 'creates new shard' do
+      subject.create(attributes)
+
+      expect(result['shortTerm'].size).to eq(2)
+      expect(shard['startTime']).to eq(Time.now.to_i)
+      expect(shard['endTime']).to eq(Time.now.to_i + 86400)
+      expect(shard['spaceName']).to be_nil
+      expect(shard['database']).to be_nil
+      expect(shard['serverIds']).to eq([1])
+    end
+  end
+
+  describe '.create', time_freeze: Time.now, version: '>0.7.3' do
+    let(:attributes){ {
+      startTime: Time.now,
+      endTime: Time.now.to_i + 86400,
+      spaceName: 'default',
+      shards: [{ serverIds: [1] }],
+      database: 'db_name'
+    } }
+    let(:shard){ result.sort_by{|v| v['id'] }.last  }
+
+    it 'creates new shard' do
+      subject.create(attributes)
+
+      expect(result.size).to eq(2)
+      expect(shard['startTime']).to eq(Time.now.to_i)
+      expect(shard['endTime']).to eq(Time.now.to_i + 86400)
+      expect(shard['spaceName']).to eq('default')
+      expect(shard['database']).to eq('db_name')
+      expect(shard['serverIds']).to eq([1])
+    end
+  end
+
+  describe '.delete' do
+    # It doesn't work on InfluxDB before 0.9.0
+    # https://github.com/influxdb/influxdb/issues/1043
+    skip("It doesn't work on InfluxDB before 0.9.0 (https://github.com/influxdb/influxdb/issues/1043)") do
+
+      let(:shard_id){ result[0]['id'] }
+
+      it 'deletes shard' do
+        expect{ subject.delete(shard_id) }.to change{ subject.all.size }.from(1).to(0)
+      end
+    end
+  end
+end

data/spec/intergrations/users_0_7_3_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe 'users', version: '<0.8.0', integration: true do
+  let(:config){ Influxdb::Api::Configuration.new }
+  let(:client){ Influxdb::Api::Client.new(config) }
+
+  subject{ client.databases('db_name').users }
+
+  before do
+    client.databases.create('db_name')
+    subject.all.each{|u| subject.delete(u['name']) }
+  end
+
+  after{ client.databases.delete('db_name') }
+
+  describe '.all' do
+    context 'when there are no users' do
+      it 'returns empty array' do
+        expect(subject.all).to eq([])
+      end
+    end
+
+    context 'when there are some users' do
+      before do
+        subject.create(name: 'username1', password: 'mypass1')
+        subject.create(name: 'username2', password: 'mypass2')
+      end
+
+      it 'returns the list of users' do
+        expect(subject.all).to match_array([
+          { 'name' => 'username1', 'isAdmin' => false },
+          { 'name' => 'username2', 'isAdmin' => false }
+        ])
+      end
+    end
+  end
+
+  describe '.create' do
+    it 'creates a new user with given name' do
+      expect{ subject.create(name: 'username', password: 'mypass') }.to change{ subject.all.size }.from(0).to(1)
+    end
+
+    context 'when there is user with the same name' do
+      before{ subject.create(name: 'username', password: 'mypass') }
+
+      it 'raises error' do
+        expect{ subject.create(name: 'username', password: 'mypass') }.to raise_error(
+          Influxdb::Api::Client::Errors::BadRequest, '[400] User username already exists'
+        )
+      end
+    end
+  end
+
+  describe '.update' do
+    context 'when user does not exist' do
+      it 'raises error' do
+        expect{ subject.update('username', admin: true) }.to raise_error(
+          Influxdb::Api::Client::Errors::BadRequest, '[400] Invalid username username'
+        )
+      end
+    end
+
+    context 'when user exists' do
+      before{ subject.create(name: 'username', password: 'mypass') }
+
+      it 'updates user attributes' do
+        subject.update('username', admin: true)
+        expect(subject.all).to eq([{ 'name' => 'username', 'isAdmin' => true }])
+      end
+    end
+  end
+
+  describe '.find' do
+    context 'when user does not exist' do
+      it 'returns nil' do
+        expect(subject.find('username2')).to be_nil
+      end
+    end
+
+    context 'when user exists' do
+      before{ subject.create(name: 'username', password: 'mypass') }
+
+      it 'returns user' do
+        expect(subject.find('username')).to eq('name' => 'username', 'isAdmin' => false)
+      end
+    end
+  end
+
+  describe '.delete' do
+    context 'when user does not exist' do
+      it 'returns false' do
+        expect(subject.delete('username')).to be_falsy
+      end
+    end
+
+    context 'when user exists' do
+      before{ subject.create(name: 'username', password: 'mypass') }
+
+      it 'removes db and returns true' do
+        expect(subject.delete('username')).to be_truthy
+      end
+    end
+  end
+end