norikra 0.0.13-java → 0.0.14-java

data/spec/spec_helper.rb

@@ -46,10 +46,46 @@ end
 # 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')
+
+require 'norikra/logger'
+
+$dummylogger = Norikra::DummyLogger.new
+Norikra::Log.init('test', nil, {:logger => $dummylogger})
+
+require 'norikra/engine'
+
+$running = {}
+
+module Norikra::SpecHelper
+  def logger ; $dummylogger ; end
+  def engine_start
+    service = com.espertech.esper.client.EPServiceProviderManager.getDefaultProvider
+    administrator = service.getEPAdministrator
+    config = administrator.getConfiguration
+    runtime = service.getEPRuntime
+    $running = {
+      service: service,
+      administrator: administrator,
+      config: config,
+      runtime: runtime,
+    }
+  end
+  def engine_stop
+    administrator.stopAllStatements
+    $running = {}
+  end
+  def with_engine
+    engine_start
+    val = yield
+    engine_stop
+    val
+  end
+  def service ; $running[:service] ; end
+  def config ; $running[:config] ; end
+  def runtime ; $running[:runtime] ; end
+  def administrator ; $running[:administrator] ; end
+end

data/spec/target_spec.rb

@@ -21,4 +21,22 @@ describe Norikra::Target do
       expect(Norikra::Target.valid?('_Foo')).to be_false
     end
   end
+
+  describe '==' do
+    it 'returns true whenever 2 targets have same name' do
+      t1 = Norikra::Target.new("target1")
+      t2 = Norikra::Target.new("target2")
+      t3 = Norikra::Target.new("target3")
+      tt = Norikra::Target.new("target1")
+
+      expect(t1 == tt).to be_true
+      expect(t2 == tt).to be_false
+      expect(t3 == tt).to be_false
+
+      expect([t1, t2, t3].include?(tt)).to be_true
+      expect([t2, t3].include?(tt)).to be_false
+
+      expect([t1, t2, t3].include?("target1")).to be_true
+    end
+  end
 end

data/spec/typedef_manager_spec.rb

@@ -67,12 +67,6 @@ describe Norikra::TypedefManager do
         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','y'])).to be_false
-      end
-    end
 
     describe '#ready?' do
       context 'with query with single target' do
@@ -101,6 +95,41 @@ describe Norikra::TypedefManager do
       end
     end
 
+    describe '#register_waiting_fields' do
+      context 'with query with single target' do
+        it 'add no fields into waiting_fields about known fields only' do
+          q1 = Norikra::Query.new(:name => 'test', :expression => 'select a,b from sample.win:time(5 sec) where c > 1.0')
+          manager.register_waiting_fields(q1)
+          q2 = Norikra::Query.new(:name => 'test', :expression => 'select a,b from sample.win:time(5 sec) where c > 1.0 and z')
+          manager.register_waiting_fields(q2)
+          q3 = Norikra::Query.new(:name => 'test', :expression => 'select a from sample_next.win:time(5 sec) where c > 1.0 and d > 2.0')
+          manager.register_waiting_fields(q3)
+
+          expect(manager.typedefs['sample'].waiting_fields).to eql([])
+          expect(manager.typedefs['sample_next'].waiting_fields).to eql([])
+        end
+      end
+
+      context 'with query with single target with unknown fields' do
+        it 'adds unknown fields into waiting_fields' do
+          expect(manager.typedefs['sample'].waiting_fields).to eql([])
+          expect(manager.typedefs['sample_next'].waiting_fields).to eql([])
+
+          q1 = Norikra::Query.new(:name => 'test', :expression => 'select a from sample.win:time(5 sec) where c > 1.0 and p')
+          manager.register_waiting_fields(q1)
+          q2 = Norikra::Query.new(:name => 'test', :expression => 'select a from sample.win:time(5 sec) where c > 1.0 and p and q')
+          manager.register_waiting_fields(q2)
+          q3 = Norikra::Query.new(:name => 'test', :expression => 'select a,e from sample_next.win:time(5 sec) where c > 1.0 and d > 2.0')
+          manager.register_waiting_fields(q3)
+
+          expect(q1.fields('sample')).to eql(['a','c','p'])
+          expect(q2.fields('sample')).to eql(['a','c','p','q'])
+          expect(manager.typedefs['sample'].waiting_fields).to eql(['p', 'q'])
+          expect(manager.typedefs['sample_next'].waiting_fields).to eql(['e'])
+        end
+      end
+    end
+
     describe '#generate_fieldset_mapping' do
       it 'retuns collect mapping for fieldsets' do
         q1 = Norikra::Query.new(:name => 'test', :expression => 'select a from sample.win:time(5 sec) where c > 1.0 and z')
@@ -151,12 +180,6 @@ describe Norikra::TypedefManager do
       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'}

data/spec/typedef_spec.rb

@@ -39,6 +39,16 @@ describe Norikra::Typedef do
         expect(t.fields['l'].type).to eql('long')
         expect(t.fields['l'].optional?).to be_false
       end
+
+      it 'remove waiting field' do
+        t = Norikra::Typedef.new
+        t.waiting_fields = ['c', 'l', 'k', 'z']
+
+        t.reserve('k', 'string')
+        t.reserve('l', 'long', false)
+
+        expect(t.waiting_fields).to eql(['c','z'])
+      end
     end
 
     describe '#activate' do
@@ -55,6 +65,32 @@ describe Norikra::Typedef do
           expect(t.baseset.object_id).not_to eql(set.object_id)
         end
       end
+
+      context 'with waiting fields' do
+        it 'remove fields in waitings' do
+          t = Norikra::Typedef.new
+          t.waiting_fields = ['a', 'c']
+
+          set = Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double'})
+          set.target = 'testing'
+          set.level = :base
+          t.activate(set)
+
+          expect(t.waiting_fields).to eql([])
+        end
+
+        it 'does not remove fields in waitings without definition in base fieldset' do
+          t = Norikra::Typedef.new
+          t.waiting_fields = ['a', 'c', 'x', 'y', 'z']
+
+          set = Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double'})
+          set.target = 'testing'
+          set.level = :base
+          t.activate(set)
+
+          expect(t.waiting_fields).to eql(['x', 'y', 'z'])
+        end
+      end
     end
   end
 
@@ -75,6 +111,14 @@ describe Norikra::Typedef do
       expect(t.fields['b'].optional?).to be_false
     end
 
+    it 'has container fields with chained access fields' do
+      t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long', 'c.0' => 'boolean'})
+      expect(t.fields.size).to eql(3)
+      expect(t.container_fields.size).to eql(1)
+      expect(t.container_fields['c'].name).to eql('c')
+      expect(t.container_fields['c'].type).to eql('array')
+    end
+
     describe '#lazy?' do
       it 'returns false' do
         t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
@@ -183,6 +227,38 @@ describe Norikra::Typedef do
         expect(t.fields['d'].type).to eql('string')
         expect(t.fields['d'].optional?).to be_true
       end
+
+      it 'deletes waiting fields' do
+        t = Norikra::Typedef.new({'a'=>'string','b'=>'long'})
+        t.waiting_fields = ['c', 'd', 'e']
+
+        t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long'}))
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long'}))
+
+        expect(t.waiting_fields.size).to eql(3)
+
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double'}))
+        expect(t.waiting_fields).to eql(['d','e'])
+
+        t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long','d'=>'string'}))
+        expect(t.waiting_fields).to eql(['e'])
+      end
+
+      it 'deletes waiting chained access fields' do
+        t = Norikra::Typedef.new({'a'=>'string','b'=>'long'})
+        t.waiting_fields = ['c', 'd', 'e', 'f.0', 'f.1', 'g.fieldx']
+
+        t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long'}))
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long'}))
+
+        expect(t.waiting_fields.size).to eql(6)
+
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double','g.fieldy'=>'long','g.fieldz'=>'string'}))
+        expect(t.waiting_fields).to eql(['d','e','f.0','f.1','g.fieldx'])
+
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long','d'=>'string','f.0'=>'long','f.1'=>'long','g.fieldx'=>'string'}))
+        expect(t.waiting_fields).to eql(['e'])
+      end
     end
 
     describe '#pop' do
@@ -232,9 +308,81 @@ describe Norikra::Typedef do
       end
     end
 
+    describe '#simple_guess' do
+      it 'can guess field definitions with class of values' do
+        typedef = Norikra::Typedef.new({'key1' => 'boolean'})
+        t = typedef.simple_guess({'key1' => true, 'key2' => false, 'key3' => 10, 'key4' => 3.1415, 'key5' => 'foobar'})
+        r = t.definition
+        expect(r['key1']).to eql('boolean')
+        expect(r['key2']).to eql('boolean')
+        expect(r['key3']).to eql('long')
+        expect(r['key4']).to eql('double')
+        expect(r['key5']).to eql('string')
+        expect(r.keys.size).to eql(5)
+      end
+
+      it 'does not guess with content of string values, nor containers' do
+        typedef = Norikra::Typedef.new({})
+        t = typedef.simple_guess({'key1' => 'TRUE', 'key2' => 'false', 'key3' => "10", 'key4' => '3.1415', 'key5' => {:a => 1}})
+        r = t.definition
+        expect(r.size).to eql(4)
+        expect(r['key1']).to eql('string')
+        expect(r['key2']).to eql('string')
+        expect(r['key3']).to eql('string')
+        expect(r['key4']).to eql('string')
+      end
+
+      it 'can guess about fields already known with strict mode' do
+        typedef = Norikra::Typedef.new({'key1' => 'boolean', 'key2' => 'boolean', 'key3' => 'long'})
+        t = typedef.simple_guess({'key1' => true, 'key2' => false, 'key3' => 10, 'key4' => 3.1415, 'key5' => 'foobar'}, true, true)
+        r = t.definition
+        expect(r['key1']).to eql('boolean')
+        expect(r['key2']).to eql('boolean')
+        expect(r['key3']).to eql('long')
+        expect(r['key4']).to be_nil
+        expect(r['key5']).to be_nil
+        expect(r.keys.size).to eql(3)
+      end
+
+      it 'can guess about fields already known or waiting fields with strict mode' do
+        typedef = Norikra::Typedef.new({'key1' => 'boolean', 'key2' => 'boolean', 'key3' => 'long'})
+        typedef.waiting_fields = ['key5']
+
+        t = typedef.simple_guess({'key1' => true, 'key2' => false, 'key3' => 10, 'key4' => 3.1415, 'key5' => 'foobar'}, true, true)
+        r = t.definition
+        expect(r['key1']).to eql('boolean')
+        expect(r['key2']).to eql('boolean')
+        expect(r['key3']).to eql('long')
+        expect(r['key4']).to be_nil
+        expect(r['key5']).to eql('string')
+        expect(r.keys.size).to eql(4)
+      end
+
+      it 'can guess about container chain access fields which pre-defined or be waiting' do
+        typedef = Norikra::Typedef.new({'key1' => 'boolean', 'key2' => 'long', 'key3.$0.key4' => 'string'})
+        typedef.waiting_fields = ['key4.f1', 'key4.f2.$0', 'key5']
+
+        t = typedef.simple_guess({
+            'key1' => true,
+            'key2' => 10,
+            'key3' => [{'k2' => 1, 'k3' => 'sssss', 'key4' => 'baz'}],
+            'key4' => {'f1' => 'xxx', 'f2' => [30, true]},
+            'key5' => 'foobar'
+          }, true, true)
+        r = t.definition
+        expect(r.size).to eql(6)
+        expect(r['key1']).to eql('boolean')
+        expect(r['key2']).to eql('long')
+        expect(r['key3$$0$key4']).to eql('string')
+        expect(r['key4$f1']).to eql('string')
+        expect(r['key4$f2$$0']).to eql('long')
+        expect(r['key5']).to eql('string')
+      end
+    end
+
     describe '#refer' do
-      context 'for event defined by data-fieldset already known' do
-        it 'returns fieldset that already known itself' do
+      context 'in non-strict mode' do
+        it 'returns fieldset that already known itself for event defined by data-fieldset already known' do
           t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
 
           set1 = Norikra::FieldSet.new({'a'=>'string','b'=>'long'})
@@ -244,10 +392,8 @@ describe Norikra::Typedef do
           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
+        it 'returns fieldset that is overwritten with known field definitions for event with known fields only' do
           t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
           t.reserve('c','boolean',true)
           t.reserve('d','double',true)
@@ -261,10 +407,8 @@ describe Norikra::Typedef do
           expect(r.fields['d'].type).to eql('double')
           expect(r.summary).to eql('a:string,b:long,c:boolean,d:double')
         end
-      end
 
-      context 'for event with some unknown fields' do
-        it 'returns fieldset that contains fields as string for unknowns' do
+        it 'returns fieldset that contains fields as string for unknowns for event with some unknown fields' do
           t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
 
           r = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14'})
@@ -277,23 +421,72 @@ describe Norikra::Typedef do
           expect(r.summary).to eql('a:string,b:long,c:string,d: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)
+      context 'in strict mode' do
+        it 'returns fieldset that already known itself for event defined by data-fieldset already known' 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}, true)
+          expect(r).to be_instance_of(Norikra::FieldSet)
+          expect(r.object_id).to eql(set1.object_id)
+        end
+
+        it 'returns fieldset that is overwritten with known field definitions for event with known fields only' 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'}, true)
+          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')
+          expect(r.summary).to eql('a:string,b:long,c:boolean,d:double')
+        end
+
+        it 'returns fieldset that contains fields already known only for event with some unknown fields' do
+          t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+
+          r1 = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14'}, true)
+          expect(t.datafieldsets.include?(r1)).to be_false
+
+          expect(r1.fields['a'].type).to eql('string')
+          expect(r1.fields['b'].type).to eql('long')
+          expect(r1.summary).to eql('a:string,b:long')
+
+          r2 = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14', 'e' => 'yeeeeeees!'}, true)
+          expect(t.datafieldsets.include?(r2)).to be_false
+
+          expect(r2.fields['a'].type).to eql('string')
+          expect(r2.fields['b'].type).to eql('long')
+          expect(r2.summary).to eql('a:string,b:long')
+        end
+
+        it 'returns fieldset that contains fields already known or waiting fields for event with some unknown fields' do
+          t = Norikra::Typedef.new({'a' => 'string', 'b' => 'long'})
+          t.waiting_fields = ['d']
+
+          r1 = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14'}, true)
+          expect(t.datafieldsets.include?(r1)).to be_false
+
+          expect(r1.fields['a'].type).to eql('string')
+          expect(r1.fields['b'].type).to eql('long')
+          expect(r1.fields['d'].type).to eql('string')
+          expect(r1.summary).to eql('a:string,b:long,d:string')
+
+          r2 = t.refer({'a'=>'hoge','b'=>'2000','c'=>'true','d'=>'3.14', 'e' => 'yeeeeeees!'}, true)
+          expect(t.datafieldsets.include?(r2)).to be_false
+
+          expect(r2.fields['a'].type).to eql('string')
+          expect(r2.fields['b'].type).to eql('long')
+          expect(r1.fields['d'].type).to eql('string')
+          expect(r2.summary).to eql('a:string,b:long,d:string')
+        end
       end
     end
 
@@ -317,6 +510,24 @@ describe Norikra::Typedef do
         expect(t2.fields.keys.sort).to eql(fields.keys.sort)
         expect(t2.fields.values.map(&:to_hash)).to eql(fields.values.map(&:to_hash))
       end
+
+      it 'returns hash instance to show fields which contains hash/array fields' do
+        t = Norikra::Typedef.new({'a'=>'string','b'=>'long'})
+        t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long','e.0'=>'string'}))
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long','e.0'=>'string','e.1'=>'long'}))
+        t.push(:data, Norikra::FieldSet.new({'a'=>'string','b'=>'long','c'=>'double','f.f1'=>'string'}))
+        t.push(:query, Norikra::FieldSet.new({'a'=>'string','b'=>'long','d'=>'string'}))
+        fields = t.fields
+
+        r = t.dump
+        expect(r.keys.sort).to eql([:a, :b, :c, :d, :e, :f])
+        expect(r[:a]).to eql({name: 'a', type: 'string', optional: false})
+        expect(r[:b]).to eql({name: 'b', type: 'long', optional: false})
+        expect(r[:c]).to eql({name: 'c', type: 'double', optional: true})
+        expect(r[:d]).to eql({name: 'd', type: 'string', optional: true})
+        expect(r[:e]).to eql({name: 'e', type: 'array', optional: true})
+        expect(r[:f]).to eql({name: 'f', type: 'hash', optional: true})
+      end
     end
   end
 end