norikra 0.0.1-java

data/spec/output_pool_spec.rb

@@ -0,0 +1,75 @@
+require_relative './spec_helper'
+
+require 'norikra/output_pool'
+
+describe Norikra::OutputPool do
+  context 'without any events in pool' do
+    describe '#pop' do
+      it 'returns blank array' do
+        expect(subject.pop('TestTable query1')).to eql([])
+      end
+    end
+
+    describe '#push' do
+      context 'with empty array' do
+        subject { p = Norikra::OutputPool.new; p.push('TestTable query1', []); p }
+        its(:pool){ should == {'TestTable query1' => []} }
+      end
+
+      context 'with event array' do
+        it 'has pool with event' do
+          pool = Norikra::OutputPool.new
+          t = Time.now.to_i
+          pool.push('TestTable query1', [{'count'=>1},{'count'=>2}])
+
+          pool.pool.keys.should eql(['TestTable query1'])
+          events = pool.pool['TestTable query1']
+
+          expect(events.size).to eq(1) # pool event bucket size is equal to times of #push
+          expect(events.first.size).to eq(2) # bucket size if equal to event num of #push
+
+          bucket = events.first
+
+          expect(t..(t+1)).to cover(bucket[0].first) # time
+          expect(bucket[0].last).to eql({'count'=>1})
+
+          expect(t..(t+1)).to cover(bucket[1].first) # time
+          expect(bucket[1].first).to eql(bucket[0].first)
+          expect(bucket[1].last).to eql({'count'=>2})
+        end
+      end
+    end
+  end
+
+  context 'with events in pool' do
+    describe '#pop' do
+      it 'returns all events of specified query in pool' do
+        pool = Norikra::OutputPool.new
+        t = Time.now.to_i
+        pool.push('TestTable query1', [{'count'=>1},{'count'=>2}])
+        pool.push('TestTable query2', [{'count'=>3},{'count'=>4}])
+
+        expect(pool.pop('TestTable query0').size).to eql(0)
+        expect(pool.pop('TestTable query1').size).to eql(2)
+        expect(pool.pool.size).to eql(1)
+        expect(pool.pop('TestTable query1').size).to eql(0)
+      end
+    end
+
+    describe '#sweep' do
+      it 'returns all events for all queries in pool' do
+        pool = Norikra::OutputPool.new
+        t = Time.now.to_i
+        pool.push('TestTable query1', [{'count'=>1},{'count'=>2}])
+        pool.push('TestTable query2', [{'count'=>3},{'count'=>4},{'count'=>5}])
+
+        chunk = pool.sweep
+        expect(chunk.keys.size).to eql(2)
+
+        expect(chunk['TestTable query1'].size).to eql(2)
+        expect(chunk['TestTable query2'].size).to eql(3)
+        expect(chunk['TestTable query2'].last.last['count']).to eql(5)
+      end
+    end
+  end
+end

data/spec/query_spec.rb

@@ -0,0 +1,82 @@
+require_relative './spec_helper'
+
+require 'norikra/query'
+
+describe Norikra::Query do
+  context 'when instanciate' do
+    describe '#initialize' do
+      context 'with simple query' do
+        expression = 'SELECT count(*) AS cnt FROM TestTable.win:time_batch(10 sec) WHERE path="/" AND size > 100 and param.length() > 0'
+        subject { Norikra::Query.new(
+            :name => 'TestTable query1', :expression => expression
+        ) }
+        its(:name){ should == 'TestTable query1' }
+        its(:expression){ should == expression }
+        its(:target){ should == 'TestTable' }
+        its(:fields){ should == ['param', 'path', 'size'] }
+      end
+      context 'with query including Static lib call'
+        expression = 'SELECT count(*) AS cnt FROM TestTable.win:time_batch(10 sec) WHERE path="/" AND Math.abs(-1 * size) > 3'
+        subject { Norikra::Query.new(
+            :name => 'TestTable query1', :expression => expression
+        ) }
+        its(:name){ should == 'TestTable query1' }
+        its(:expression){ should == expression }
+        its(:target){ should == 'TestTable' }
+        its(:fields){ should == ['path', 'size'] }
+    end
+    describe '#dup_with_stream_name' do
+      context 'with simple query' do
+        expression = 'SELECT count(*) AS cnt FROM TestTable.win:time_batch(10 sec) WHERE path="/" AND size > 100 and param.length() > 0'
+        it 'returns duplicated object, with replaced ' do
+          query = Norikra::Query.new(
+            :name => 'TestTable query1', :expression => expression
+          )
+          expect(query.dup_with_stream_name('hoge').expression).to eql(
+            'SELECT count(*) AS cnt FROM hoge.win:time_batch(10 sec) WHERE path="/" AND size > 100 and param.length() > 0'
+          )
+        end
+      end
+      context 'with query with newlines' do
+        expression = <<EOQ
+SELECT
+  count(*) AS cnt
+FROM TestTable.win:time_batch(10 sec)
+WHERE path="/" AND size > 100
+  AND param.length() > 0
+EOQ
+        expected_query = <<EOQ
+SELECT
+  count(*) AS cnt
+FROM hoge.win:time_batch(10 sec)
+WHERE path="/" AND size > 100
+  AND param.length() > 0
+EOQ
+        it 'returns duplicated object, with replaced ' do
+          query = Norikra::Query.new(
+            :name => 'TestTable query1', :expression => expression
+          )
+          expect(query.dup_with_stream_name('hoge').expression).to eql(expected_query)
+        end
+      end
+    end
+  end
+  describe '.imported_java_class?' do
+    it 'can do judge passed name exists under java package tree or not' do
+      expect(Norikra::Query.imported_java_class?('String')).to be_true
+      expect(Norikra::Query.imported_java_class?('Long')).to be_true
+      expect(Norikra::Query.imported_java_class?('Void')).to be_true
+      expect(Norikra::Query.imported_java_class?('BigDecimal')).to be_true
+      expect(Norikra::Query.imported_java_class?('Format')).to be_true
+      expect(Norikra::Query.imported_java_class?('Normalizer')).to be_true
+      expect(Norikra::Query.imported_java_class?('Date')).to be_true
+      expect(Norikra::Query.imported_java_class?('HashSet')).to be_true
+      expect(Norikra::Query.imported_java_class?('Random')).to be_true
+      expect(Norikra::Query.imported_java_class?('Timer')).to be_true
+
+      expect(Norikra::Query.imported_java_class?('unexpected')).to be_false
+      expect(Norikra::Query.imported_java_class?('parameter')).to be_false
+      expect(Norikra::Query.imported_java_class?('param')).to be_false
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'spork'
+#uncomment the following line to use spork with the debugger
+#require 'spork/ext/ruby-debug'
+
+Spork.prefork do
+  # Loading more in this block will cause your tests to run faster. However,
+  # if you change any configuration or code from libraries loaded here, you'll
+  # need to restart spork for it take effect.
+
+end
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+  Dir.glob('./lib/norikra/**/*.rb').each do |file|
+    load file
+  end
+end
+
+# --- Instructions ---
+# Sort the contents of this file into a Spork.prefork and a Spork.each_run
+# block.
+#
+# The Spork.prefork block is run only once when the spork server is started.
+# You typically want to place most of your (slow) initializer code in here, in
+# particular, require'ing any 3rd-party gems that you don't normally modify
+# during development.
+#
+# The Spork.each_run block is run each time you run your specs.  In case you
+# need to load files that tend to change during development, require them here.
+# With Rails, your application modules are loaded automatically, so sometimes
+# this block can remain empty.
+#
+# Note: You can modify files loaded *from* the Spork.each_run block without
+# restarting the spork server.  However, this file itself will not be reloaded,
+# so if you change any of the code inside the each_run block, you still need to
+# restart the server.  In general, if you have non-trivial code in this file,
+# it's advisable to move it into a separate file so you can easily edit it
+# without restarting spork.  (For example, with RSpec, you could move
+# non-trivial code into a file spec/support/my_helper.rb, making sure that the
+# spec/support/* files are require'd from inside the each_run block.)
+#
+# Any code that is left outside the two blocks will be run during preforking
+# *and* during each_run -- that's probably not what you want.
+#
+# These instructions should self-destruct in 10 seconds.  If they don't, feel
+# free to delete them.
+
+
+
+
+require 'rubygems'
+require 'rspec'
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../esper')

data/spec/typedef_manager_spec.rb

@@ -0,0 +1,128 @@
+require_relative './spec_helper'
+
+require 'norikra/typedef_manager'
+
+require 'norikra/typedef'
+
+describe Norikra::TypedefManager do
+  context 'when instanciated with a target without fields definition' do
+    manager = Norikra::TypedefManager.new
+    manager.add_target('sample', nil)
+
+    describe '#lazy?' do
+      it 'returns true' do
+        expect(manager.lazy?('sample')).to be_true
+      end
+    end
+
+    describe '#generate_base_fieldset' do
+      it 'returns fieldsets specified as all fields required' do
+        r = manager.generate_base_fieldset('sample', {'a'=>'foo','b'=>'bar','x'=>'yeeeees!'})
+        expect(r).to be_instance_of(Norikra::FieldSet)
+
+        expect(r.fields['a'].type).to eql('string')
+        expect(r.fields['a'].optional?).to be_false
+        expect(r.fields['b'].type).to eql('string')
+        expect(r.fields['b'].optional?).to be_false
+        expect(r.fields['x'].type).to eql('string')
+        expect(r.fields['x'].optional?).to be_false
+      end
+    end
+
+    describe '#activate' do
+      it 'does not fail, and target will become non-lazy status' do
+        r = manager.generate_base_fieldset('sample', {'a'=>'foo','b'=>'bar','x'=>'yeeeees!'})
+        manager.activate('sample', r)
+        expect(manager.lazy?('sample')).to be_false
+      end
+    end
+  end
+
+  context 'when instanciated with a target with fields definition' do
+    manager = Norikra::TypedefManager.new
+    manager.add_target('sample', {'a'=>'string','b'=>'string','c'=>'double'})
+
+    set_query_base = Norikra::FieldSet.new({'a'=>'string','b'=>'string','c'=>'double'})
+
+    it 'three fields are defined as non-optional fields' do
+      expect(manager.typedefs['sample'].fields['a'].type).to eql('string')
+      expect(manager.typedefs['sample'].fields['a'].optional?).to be_false
+      expect(manager.typedefs['sample'].fields['b'].type).to eql('string')
+      expect(manager.typedefs['sample'].fields['b'].optional?).to be_false
+      expect(manager.typedefs['sample'].fields['c'].type).to eql('double')
+      expect(manager.typedefs['sample'].fields['c'].optional?).to be_false
+    end
+
+    describe '#lazy?' do
+      it 'returns false' do
+        expect(manager.lazy?('sample')).to be_false
+      end
+    end
+    describe '#reserve' do
+      it 'does not fail' do
+        manager.reserve('sample', 'x', 'long')
+        expect(manager.typedefs['sample'].fields['x'].type).to eql('long')
+        expect(manager.typedefs['sample'].fields['x'].optional?).to be_true
+      end
+    end
+    describe '#fields_defined?' do
+      it 'does not fail' do
+        expect(manager.fields_defined?('sample', ['a','b','x'])).to be_true
+        expect(manager.fields_defined?('sample', ['a','b','z'])).to be_false
+      end
+    end
+    describe '#bind_fieldset' do
+      it 'does not fail' do
+        manager.bind_fieldset('sample', :query, set_query_base)
+        expect(set_query_base.target).to eql('sample')
+        expect(set_query_base.level).to eql(:query)
+        expect(manager.typedefs['sample'].queryfieldsets.include?(set_query_base)).to be_true
+      end
+    end
+
+    describe '#base_fieldset' do
+      it 'returns baseset of specified target' do
+        expect(manager.base_fieldset('sample').object_id).to eql(manager.typedefs['sample'].baseset.object_id)
+      end
+    end
+
+    describe '#refer' do
+      it 'does not fail' do
+        expect(manager.refer('sample', {'a'=>'foo','b'=>'bar','c'=>'0.03'})).to be_instance_of(Norikra::FieldSet)
+      end
+    end
+
+    describe '#format' do
+      it 'does not fail' do
+        expect(manager.format('sample', {'a'=>'foo','b'=>'bar','c'=>'0.03'})).to be_instance_of(Hash)
+      end
+    end
+
+    describe '#subsets' do
+      it 'returns list of query fieldset (and base set), subset of specified fieldset, owned by manager for specified target' do
+        base = {'a'=>'string','b'=>'string','c'=>'double'}
+        set_d = Norikra::FieldSet.new(base.merge({'d'=>'int'}))
+        manager.bind_fieldset('sample', :query, set_d)
+        set_e = Norikra::FieldSet.new(base.merge({'e'=>'double'}))
+        manager.bind_fieldset('sample', :query, set_e)
+        set_f = Norikra::FieldSet.new(base.merge({'f'=>'boolean'}))
+        manager.bind_fieldset('sample', :query, set_f)
+
+        list = manager.subsets('sample', Norikra::FieldSet.new(base.merge({'d'=>'string','e'=>'string','g'=>'string'})))
+        expect(list.size).to eql(4) # set_query_base, set_d, set_e, baseset
+        expect(list.include?(set_query_base)).to be_true
+        expect(list.include?(set_d)).to be_true
+        expect(list.include?(set_e)).to be_true
+        expect(list.include?(set_f)).to be_false
+      end
+    end
+
+    describe '#generate_query_fieldset' do
+      it 'returns fieldset instance with all required(non-optional) fields of target, and fields of query requires' do
+        r = manager.generate_query_fieldset('sample', ['a', 'b','f'])
+        expect(r.fields.size).to eql(4) # a,b,c,f
+        expect(r.summary).to eql('a:string,b:string,c:double,f:boolean')
+      end
+    end
+  end
+end

data/spec/typedef_spec.rb

@@ -0,0 +1,248 @@
+require_relative './spec_helper'
+
+require 'norikra/typedef'
+
+require 'json'
+require 'digest'
+
+describe Norikra::Typedef do
+  context 'instanciated as lazy typedef' do
+    it 'has no fields' do
+      t = Norikra::Typedef.new
+      expect(t.fields.size).to eql(0)
+      expect(t.baseset).to be_nil
+    end
+
+    it 'has no query/data fieldsets' do
+      t = Norikra::Typedef.new
+      expect(t.queryfieldsets.size).to eql(0)
+      expect(t.datafieldsets.size).to eql(0)
+    end
+
+    describe '#lazy?' do
+      it 'returns true' do
+        t = Norikra::Typedef.new
+        expect(t.lazy?).to be_true
+      end
+    end
+
+    describe '#reserve' do
+      it 'add field definition without any baseset' do
+        t = Norikra::Typedef.new
+
+        t.reserve('k', 'string')
+        expect(t.fields['k'].type).to eql('string')
+        expect(t.fields['k'].optional?).to be_true
+
+        t.reserve('l', 'long', false)
+        expect(t.fields['l'].type).to eql('long')
+        expect(t.fields['l'].optional?).to be_false
+      end
+    end
+
+    describe '#activate' do
+      context 'without any fields reserved' do
+        it 'stores all fields in specified fieldset' do
+          t = Norikra::Typedef.new
+          set = Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double'})
+          t.activate(set)
+          expect(t.fields.size).to eql(3)
+          expect(t.fields['a'].optional?).to be_false
+          expect(t.fields.object_id).not_to eql(set.fields.object_id)
+          expect(t.baseset.object_id).not_to eql(set.object_id)
+        end
+      end
+    end
+  end
+
+  context 'instanciated as non-lazy typedef' do
+    it 'has no query/data fieldsets' do
+      t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+      expect(t.queryfieldsets.size).to eql(0)
+      expect(t.datafieldsets.size).to eql(0)
+    end
+
+    it 'has all fields as required' do
+      t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+
+      expect(t.fields['a'].type).to eql('string')
+      expect(t.fields['a'].optional?).to be_false
+
+      expect(t.fields['b'].type).to eql('long')
+      expect(t.fields['b'].optional?).to be_false
+    end
+
+    describe '#lazy?' do
+      it 'returns false' do
+        t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+        expect(t.lazy?).to be_false
+      end
+    end
+
+    describe '#field_defined?' do
+      it 'returns boolean to indicate all fields specified exists or not' do
+        t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+        expect(t.field_defined?(['a','b'])).to be_true
+        expect(t.field_defined?(['a'])).to be_true
+        expect(t.field_defined?(['b'])).to be_true
+        expect(t.field_defined?([])).to be_true
+        expect(t.field_defined?(['a','b','c'])).to be_false
+        expect(t.field_defined?(['a','c'])).to be_false
+        expect(t.field_defined?(['c'])).to be_false
+      end
+    end
+
+    describe '#reserve' do
+      it 'adds field definitions as required or optional' do
+        t = Norikra::Typedef.new({'a' => 'string'})
+
+        expect(t.fields.size).to eql(1)
+
+        t.reserve('b', 'boolean', false)
+        expect(t.fields.size).to eql(2)
+        expect(t.fields['b'].type).to eql('boolean')
+        expect(t.fields['b'].optional?).to be_false
+
+        t.reserve('c', 'double', true)
+        expect(t.fields.size).to eql(3)
+        expect(t.fields['c'].type).to eql('double')
+        expect(t.fields['c'].optional?).to be_true
+      end
+    end
+
+    describe '#consistent?' do
+      context 'without any additional reserved fields' do
+        it 'checks all fields of specified fieldset are super-set of baseset or not' do
+          t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long'})
+          expect(t.consistent?(set)).to be_true
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long', 'c' => 'double'})
+          expect(t.consistent?(set)).to be_true
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'int'})
+          expect(t.consistent?(set)).to be_false
+
+          set = Norikra::FieldSet.new({'a' => 'string'})
+          expect(t.consistent?(set)).to be_false
+        end
+      end
+
+      context 'with some additional reserved fields' do
+        it 'checks all fields of specified fieldset with baseset and additional reserved fields' do
+          t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+          t.reserve('c', 'double', false) # required
+          t.reserve('d', 'boolean', true) # optional
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long'})
+          expect(t.consistent?(set)).to be_false
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long', 'c' => 'double'})
+          expect(t.consistent?(set)).to be_true
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long', 'c' => 'double', 'd' => 'boolean'})
+          expect(t.consistent?(set)).to be_true
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long', 'c' => 'double', 'd' => 'string'})
+          expect(t.consistent?(set)).to be_false
+
+          set = Norikra::FieldSet.new({'a' => 'string', 'b' => 'long', 'c' => 'double', 'd' => 'boolean', 'e' => 'string'})
+          expect(t.consistent?(set)).to be_true
+        end
+      end
+    end
+
+    describe '#push' do
+      it 'does not accepts fieldset which conflicts pre-defined fields' do
+        t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+        expect { t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'int'})) }.to raise_error(ArgumentError)
+        expect { t.push(:data, Norikra::FieldSet.new({'a'=>'string'})) }.to raise_error(ArgumentError)
+      end
+
+      it 'accepts fieldsets which is consistent with self' do
+        t = Norikra::Typedef.new({'a'=>'string','b'=>'long'})
+        expect(t.fields.size).to eql(2)
+
+        expect { t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long'})) }.not_to raise_error(ArgumentError)
+        expect { t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long'})) }.not_to raise_error(ArgumentError)
+
+        expect(t.fields.size).to eql(2)
+
+        set_a = Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double'})
+        t.push(:data, set_a)
+        expect(t.fields.size).to eql(3)
+        expect(t.fields['c'].type).to eql('double')
+        expect(t.fields['c'].optional?).to be_true
+
+        t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long','d'=>'string'}))
+        expect(t.fields.size).to eql(4)
+        expect(t.fields['d'].type).to eql('string')
+        expect(t.fields['d'].optional?).to be_true
+      end
+    end
+
+    describe '#refer' do
+      context 'for event defined by data-fieldset already known' do
+        it 'returns fieldset that already known itself' do
+          t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+
+          set1 = Norikra::FieldSet.new({'a'=>'string','b'=>'long'})
+          t.push(:data, set1)
+
+          r = t.refer({'a'=>'foobar','b'=>200000000})
+          expect(r).to be_instance_of(Norikra::FieldSet)
+          expect(r.object_id).to eql(set1.object_id)
+        end
+      end
+
+      context 'for event with known fields only' do
+        it 'returns fieldset that is overwritten with known field definitions' do
+          t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+          t.reserve('c','boolean',true)
+          t.reserve('d','double',true)
+
+          r = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14'})
+          expect(t.datafieldsets.include?(r)).to be_false
+
+          expect(r.fields['a'].type).to eql('string')
+          expect(r.fields['b'].type).to eql('long')
+          expect(r.fields['c'].type).to eql('boolean')
+          expect(r.fields['d'].type).to eql('double')
+        end
+      end
+
+      context 'for event with some unknown fields' do
+        it 'returns fieldset that contains fields as string for unknowns' do
+          t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+
+          r = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14'})
+          expect(t.datafieldsets.include?(r)).to be_false
+
+          expect(r.fields['a'].type).to eql('string')
+          expect(r.fields['b'].type).to eql('long')
+          expect(r.fields['c'].type).to eql('string')
+          expect(r.fields['d'].type).to eql('string')
+        end
+      end
+    end
+
+    describe '#format' do
+      it 'returns hash value with formatted fields as defined' do
+        t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+        t.reserve('c','boolean',true)
+        t.reserve('d','double',true)
+
+        d = t.format({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14'})
+        expect(d['a']).to be_instance_of(String)
+        expect(d['a']).to eql('hoge')
+        expect(d['b']).to be_instance_of(Fixnum)
+        expect(d['b']).to eql(2000)
+        expect(d['c']).to be_instance_of(TrueClass)
+        expect(d['c']).to eql(true)
+        expect(d['d']).to be_instance_of(Float)
+        expect(d['d']).to eql(3.14)
+      end
+    end
+  end
+end