ruby-druid 0.1.1

data/lib/druid/response_row.rb

@@ -0,0 +1,32 @@
+module Druid
+
+  class ResponseRow
+    (instance_methods + private_instance_methods).each do |method|
+      unless method.to_s =~ /^(__|object_id|initialize)/
+        undef_method method
+      end
+    end
+
+    attr_reader :timestamp
+    attr_reader :row
+
+    def initialize(row)
+      @timestamp = row['timestamp']
+      @row = row['event'] || row['result']
+    end
+
+    def method_missing(name, *args, &block)
+      @row.send name, *args, &block
+    end
+
+    def to_s
+      "#{@timestamp.to_s}:#{@row.to_s}"
+    end
+
+    def inspect
+      "#{@timestamp.inspect}:#{@row.inspect}"
+    end
+
+  end
+
+end

data/lib/druid/zoo_handler.rb

@@ -0,0 +1,129 @@
+require 'zk'
+require 'json'
+require 'rest_client'
+
+module Druid
+
+  class ZooHandler
+    def initialize(uri, opts = {})
+      @zk = ZK.new uri, :chroot => :check
+      @registry = Hash.new {|hash,key| hash[key] = Array.new }
+      @discovery_path = opts[:discovery_path] || '/discoveryPath'
+      @watched_services = Hash.new
+
+      init_zookeeper
+    end
+
+    def init_zookeeper
+      @zk.on_expired_session do
+        init_zookeeper
+      end
+
+      @zk.register(@discovery_path, :only => :child) do |event|
+        check_services
+      end
+
+      check_services
+    end
+
+    def close!
+      @zk.close!
+    end
+
+    def check_services
+      zk_services = @zk.children @discovery_path, :watch => true
+
+      #remove deprecated services
+      (services - zk_services).each do |old_service|
+        @registry.delete old_service
+        if @watched_services.include? old_service
+          @watched_services.delete(old_service).unregister
+        end
+      end
+
+      zk_services.each do |service|
+        check_service service unless @watched_services.include? service
+      end
+    end
+
+    def check_service(service)
+      unless @watched_services.include? service
+        watchPath = "#{@discovery_path}/#{service}"
+        @watched_services[service] = @zk.register(watchPath, :only => :child) do |event|
+          old_handler = @watched_services.delete(service)
+          if old_handler
+            old_handler.unregister
+          end
+          check_service service
+        end
+
+        known = @registry[service].map{ |node| node[:name] } rescue []
+        live = @zk.children(watchPath, :watch => true)
+
+        # copy the unchanged entries
+        new_list = @registry[service].select{ |node| live.include? node[:name] } rescue []
+
+        # verify the new entries to be living brokers
+        (live - known).each do |name|
+          info = @zk.get "#{watchPath}/#{name}"
+          node = JSON.parse(info[0])
+          uri =  "http://#{node['address']}:#{node['port']}/druid/v2/"
+
+          begin
+            check_uri = "#{uri}datasources/"
+
+            check = RestClient::Request.execute({
+              :method => :get,
+              :url => check_uri,
+              :timeout => 5,
+              :open_timeout => 5
+            })
+
+            if check.code == 200
+              new_list.push({
+                :name => name,
+                :uri => uri,
+                :data_sources => JSON.parse(check.to_str)
+              })
+            else
+            end
+          rescue
+          end
+        end
+
+        if !new_list.empty?
+          # poor mans load balancing
+          @registry[service] = new_list.shuffle
+        else
+          # don't show services w/o active brokers
+          @registry.delete service
+        end
+      end
+    end
+
+    def services
+      @registry.keys
+    end
+
+    def data_sources
+      result = Hash.new { |hash, key| hash[key] = [] }
+
+      @registry.each do |service, brokers|
+        brokers.each do |broker|
+          broker[:data_sources].each do |data_source|
+            result["#{service}/#{data_source}"] << broker[:uri]
+          end
+        end
+      end
+      result.each do |source, uris|
+        result[source] = uris.sample if uris.respond_to?(:sample)
+      end
+
+      result
+    end
+
+    def to_s
+      @registry.to_s
+    end
+  end
+end

data/ruby-druid.gemspec

@@ -0,0 +1,19 @@
+require 'rake'
+
+Gem::Specification.new do |gem|
+  gem.name          = 'ruby-druid'
+  gem.version       = '0.1.1'
+  gem.date          = '2013-08-01'
+  gem.summary       = 'Ruby client for druid'
+  gem.description   = 'Ruby client for metamx druid'
+  gem.authors       = 'The LiquidM Team'
+  gem.email         = 'tech@liquidm.com'
+  gem.homepage      = 'https://github.com/madvertise/ruby-druid'
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'zk'
+  gem.add_dependency 'rest-client'
+end

data/spec/lib/client_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Druid::Client do
+
+  it 'calls zookeeper on intialize' do
+    Druid::ZooHandler.should_receive(:new)
+    Druid::Client.new('test_uri', zk_keepalive: true)
+  end
+
+  it 'creates a query' do
+    Druid::ZooHandler.stub!(:new).and_return(mock(Druid::ZooHandler, :data_sources => {'test/test' => 'http://www.example.com'}, :close! => true))
+    Druid::Client.new('test_uri', zk_keepalive: true).query('test/test').should be_a Druid::Query
+  end
+
+  it 'sends query if block is given' do
+    Druid::ZooHandler.stub!(:new).and_return(mock(Druid::ZooHandler, :data_sources => {'test/test' => 'http://www.example.com'}, :close! => true))
+    client = Druid::Client.new('test_uri', zk_keepalive: true)
+    client.should_receive(:send)
+    client.query('test/test') do
+      group(:group1)
+    end
+  end
+
+  it 'parses response on 200' do
+    stub_request(:post, "http://www.example.com/druid/v2").
+      with(:body => "{\"dataSource\":\"test\",\"granularity\":\"all\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"]}",
+      :headers => {'Accept'=>'*/*', 'Content-Type'=>'application/json', 'User-Agent'=>'Ruby'}).
+      to_return(:status => 200, :body => "[]", :headers => {})
+    Druid::ZooHandler.stub!(:new).and_return(mock(Druid::ZooHandler, :data_sources => {'test/test' => 'http://www.example.com/druid/v2'}, :close! => true))
+    client = Druid::Client.new('test_uri', zk_keepalive: true)
+    JSON.should_receive(:parse).and_return([])
+    client.send(client.query('test/test').interval("2013-04-04", "2013-04-04"))
+  end
+
+  it 'raises on request failure' do
+    stub_request(:post, "http://www.example.com/druid/v2").
+      with(:body => "{\"dataSource\":\"test\",\"granularity\":\"all\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"]}",
+      :headers => {'Accept'=>'*/*', 'Content-Type'=>'application/json', 'User-Agent'=>'Ruby'}).
+      to_return(:status => 666, :body => "Strange server error", :headers => {})
+    Druid::ZooHandler.stub!(:new).and_return(mock(Druid::ZooHandler, :data_sources => {'test/test' => 'http://www.example.com/druid/v2'}, :close! => true))
+    client = Druid::Client.new('test_uri', zk_keepalive: true)
+    expect { client.send(client.query('test/test').interval("2013-04-04", "2013-04-04")) }.to raise_error(RuntimeError, /Request failed: 666: Strange server error/)
+  end
+
+  it 'should have a static setup' do
+    client = Druid::Client.new('test_uri', :static_setup => {'madvertise/mock' => 'mock_uri'})
+    client.data_sources.should == ['madvertise/mock']
+    client.data_source_uri('madvertise/mock').should == URI('mock_uri')
+  end
+
+  it 'should report dimensions of a data source correctly' do
+    stub_request(:get, "http://www.example.com/druid/v2/datasources/mock").
+      with(:headers =>{'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
+      to_return(:status => 200, :body => '{"dimensions":["d1","d2","d3"],"metrics":["m1", "m2"]}')
+
+    client = Druid::Client.new('test_uri', :static_setup => {'madvertise/mock' => 'http://www.example.com/druid/v2/'})
+    client.data_source('madvertise/mock').dimensions.should == ["d1","d2","d3"]
+  end
+
+  it 'should report metrics of a data source correctly' do
+    stub_request(:get, "http://www.example.com/druid/v2/datasources/mock").
+      with(:headers =>{'Accept'=>'*/*', 'User-Agent'=>'Ruby'}).
+      to_return(:status => 200, :body => '{"dimensions":["d1","d2","d3"],"metrics":["m1", "m2"]}')
+
+    client = Druid::Client.new('test_uri', :static_setup => {'madvertise/mock' => 'http://www.example.com/druid/v2/'})
+    client.data_source('madvertise/mock').metrics.should == ["m1","m2"]
+  end
+
+end

data/spec/lib/query_spec.rb

@@ -0,0 +1,377 @@
+require "spec_helper"
+
+describe Druid::Query do
+
+  before :each do
+    @query = Druid::Query.new('test')
+  end
+
+  it 'takes a datasource in the constructor' do
+    query = Druid::Query.new('test')
+    JSON.parse(query.to_json)['dataSource'].should == 'test'
+  end
+
+  it 'takes a query type' do
+    @query.query_type('query_type')
+    JSON.parse(@query.to_json)['queryType'].should == 'query_type'
+  end
+
+  it 'sets query type by group_by' do
+    @query.group_by()
+    JSON.parse(@query.to_json)['queryType'].should == 'groupBy'
+  end
+  
+  it 'sets query type to timeseries' do
+    @query.time_series()
+    JSON.parse(@query.to_json)['queryType'].should == 'timeseries'
+  end
+
+  it 'takes dimensions from group_by method' do
+    @query.group_by(:a, :b, :c)
+    JSON.parse(@query.to_json)['dimensions'].should == ['a', 'b', 'c']
+  end
+
+  it 'build a post aggregation with a constant right' do
+    @query.postagg{(a + 1).as ctr }
+
+    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      "fn"=>"+",
+      "fields"=>
+      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+       {"type"=>"constant", "value"=>1}],
+      "name"=>"ctr"}]
+  end
+
+  it 'build a + post aggregation' do
+    @query.postagg{(a + b).as ctr }
+    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      "fn"=>"+",
+      "fields"=>
+      [{"type"=>"fieldAccess","name"=>"a", "fieldName"=>"a"},
+      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+      "name"=>"ctr"}]
+  end
+
+  it 'build a - post aggregation' do
+    @query.postagg{(a - b).as ctr }
+    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      "fn"=>"-",
+      "fields"=>
+      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+      "name"=>"ctr"}]
+  end
+
+  it 'build a * post aggregation' do
+    @query.postagg{(a * b).as ctr }
+    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      "fn"=>"*",
+      "fields"=>
+      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+      "name"=>"ctr"}]
+  end
+
+  it 'build a / post aggregation' do
+    @query.postagg{(a / b).as ctr }
+    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      "fn"=>"/",
+      "fields"=>
+      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+    "name"=>"ctr"}]
+  end
+
+  it 'build a complex post aggregation' do
+    @query.postagg{((a / b) * 1000).as ctr }
+    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      "fn"=>"*",
+      "fields"=>
+      [{"type"=>"arithmetic", "fn"=>"/", "fields"=>
+        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+         {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}]},
+      {"type"=>"constant", "value"=>1000}],
+    "name"=>"ctr"}]
+  end
+
+  it 'adds fields required by the postagg operation to longsum' do
+    @query.postagg{ (a/b).as c }
+    JSON.parse(@query.to_json)['aggregations'].should == [{"type"=>"longSum", "name"=>"a", "fieldName"=>"a"},
+                                                          {"type"=>"longSum", "name"=>"b", "fieldName"=>"b"}]
+  end
+
+  it 'chains aggregations' do
+    @query.postagg{(a / b).as ctr }.postagg{(b / a).as rtc }
+
+    JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      "fn"=>"/",
+      "fields"=>
+      [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+      {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+    "name"=>"ctr"},
+    {"type"=>"arithmetic",
+      "fn"=>"/",
+      "fields"=>
+      [{"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"},
+      {"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"}],
+    "name"=>"rtc"}
+    ]
+  end
+
+  it 'builds aggregations on long_sum' do
+    @query.long_sum(:a, :b, :c)
+    JSON.parse(@query.to_json)['aggregations'].should == [
+      { 'type' => 'longSum', 'name' => 'a', 'fieldName' => 'a'},
+      { 'type' => 'longSum', 'name' => 'b', 'fieldName' => 'b'},
+      { 'type' => 'longSum', 'name' => 'c', 'fieldName' => 'c'}
+    ]
+  end
+
+
+  it 'appends long_sum properties from aggregations on calling long_sum again' do
+    @query.long_sum(:a, :b, :c)
+    @query.double_sum(:x,:y)
+    @query.long_sum(:d, :e, :f)
+    JSON.parse(@query.to_json)['aggregations'].sort{|x,y| x['name'] <=> y['name']}.should == [
+      { 'type' => 'longSum', 'name' => 'a', 'fieldName' => 'a'},
+      { 'type' => 'longSum', 'name' => 'b', 'fieldName' => 'b'},
+      { 'type' => 'longSum', 'name' => 'c', 'fieldName' => 'c'},
+      { 'type' => 'longSum', 'name' => 'd', 'fieldName' => 'd'},
+      { 'type' => 'longSum', 'name' => 'e', 'fieldName' => 'e'},
+      { 'type' => 'longSum', 'name' => 'f', 'fieldName' => 'f'},
+      { 'type' => 'doubleSum', 'name' => 'x', 'fieldName' => 'x'},
+      { 'type' => 'doubleSum', 'name' => 'y', 'fieldName' => 'y'}
+    ]
+  end
+
+  it 'removes duplicate aggregation fields' do
+    @query.long_sum(:a, :b)
+    @query.long_sum(:b)
+
+    JSON.parse(@query.to_json)['aggregations'].should == [
+      { 'type' => 'longSum', 'name' => 'a', 'fieldName' => 'a'},
+      { 'type' => 'longSum', 'name' => 'b', 'fieldName' => 'b'},
+    ]
+  end
+
+  it 'must be chainable' do
+    q = [Druid::Query.new('test')]
+    q.push q[-1].query_type('a')
+    q.push q[-1].data_source('b')
+    q.push q[-1].group_by('c')
+    q.push q[-1].long_sum('d')
+    q.push q[-1].double_sum('e')
+    q.push q[-1].filter{a.eq 1}
+    q.push q[-1].interval("2013-01-26T00", "2020-01-26T00:15")
+    q.push q[-1].granularity(:day)
+
+    q.each do |instance|
+      instance.should == q[0]
+    end
+  end
+
+  it 'parses intervals from strings' do
+    @query.interval('2013-01-26T0', '2020-01-26T00:15')
+    JSON.parse(@query.to_json)['intervals'].should == ['2013-01-26T00:00:00+00:00/2020-01-26T00:15:00+00:00']
+  end
+
+  it 'takes multiple intervals' do
+    @query.intervals([['2013-01-26T0', '2020-01-26T00:15'],['2013-04-23T0', '2013-04-23T15:00']])
+    JSON.parse(@query.to_json)['intervals'].should == ["2013-01-26T00:00:00+00:00/2020-01-26T00:15:00+00:00", "2013-04-23T00:00:00+00:00/2013-04-23T15:00:00+00:00"]
+  end
+
+  it 'accepts Time objects for intervals' do
+    @query.interval(a = Time.now, b = Time.now + 1)
+    JSON.parse(@query.to_json)['intervals'].should == ["#{a.iso8601}/#{b.iso8601}"]
+  end
+
+  it 'takes a granularity from string' do
+    @query.granularity('all')
+    JSON.parse(@query.to_json)['granularity'].should == 'all'
+  end
+
+  it 'should take a period' do
+    @query.granularity(:day, 'CEST')
+    @query.properties[:granularity].should == {
+      :type => "period",
+      :period => "P1D",
+      :timeZone => "Europe/Berlin"
+    }
+  end
+
+  it 'creates an equals filter' do
+    @query.filter{a.eq 1}
+    JSON.parse(@query.to_json)['filter'].should == {"type"=>"selector", "dimension"=>"a", "value"=>1}
+  end
+
+  it 'creates an equals filter with ==' do
+    @query.filter{a == 1}
+    JSON.parse(@query.to_json)['filter'].should == {"type"=>"selector", "dimension"=>"a", "value"=>1}
+  end
+
+
+  it 'creates a not filter' do
+    @query.filter{!a.eq 1}
+    JSON.parse(@query.to_json)['filter'].should ==  {"field" =>
+      {"type"=>"selector", "dimension"=>"a", "value"=>1},
+    "type" => "not"}
+  end
+
+  it 'creates a not filter with neq' do
+    @query.filter{a.neq 1}
+    JSON.parse(@query.to_json)['filter'].should ==  {"field" =>
+      {"type"=>"selector", "dimension"=>"a", "value"=>1},
+    "type" => "not"}
+  end
+
+  it 'creates a not filter with !=' do
+    @query.filter{a != 1}
+    JSON.parse(@query.to_json)['filter'].should ==  {"field" =>
+      {"type"=>"selector", "dimension"=>"a", "value"=>1},
+    "type" => "not"}
+  end
+
+
+  it 'creates an and filter' do
+    @query.filter{a.neq(1) & b.eq(2) & c.eq('foo')}
+    JSON.parse(@query.to_json)['filter'].should ==  {"fields" => [
+      {"type"=>"not", "field"=>{"type"=>"selector", "dimension"=>"a", "value"=>1}},
+      {"type"=>"selector", "dimension"=>"b", "value"=>2},
+      {"type"=>"selector", "dimension"=>"c", "value"=>"foo"}
+    ],
+  "type" => "and"}
+end
+
+  it 'creates an or filter' do
+    @query.filter{a.neq(1) | b.eq(2) | c.eq('foo')}
+    JSON.parse(@query.to_json)['filter'].should ==  {"fields" => [
+      {"type"=>"not", "field"=> {"type"=>"selector", "dimension"=>"a", "value"=>1}},
+      {"type"=>"selector", "dimension"=>"b", "value"=>2},
+      {"type"=>"selector", "dimension"=>"c", "value"=>"foo"}
+    ],
+  "type" => "or"}
+  end
+
+  it 'chains filters' do
+    @query.filter{a.eq(1)}.filter{b.eq(2)}
+    JSON.parse(@query.to_json)['filter'].should ==  {"fields" => [
+      {"type"=>"selector", "dimension"=>"a", "value"=>1},
+      {"type"=>"selector", "dimension"=>"b", "value"=>2}
+    ],
+    "type" => "and"}
+  end
+
+  it 'creates filter from hash' do
+    @query.filter a:1, b:2
+    JSON.parse(@query.to_json)['filter'].should ==  {"fields" => [
+      {"type"=>"selector", "dimension"=>"a", "value"=>1},
+      {"type"=>"selector", "dimension"=>"b", "value"=>2}
+    ],
+    "type" => "and"}
+
+  end
+
+  it 'creates an in statement with or filter' do
+    @query.filter{a.in [1,2,3]}
+    JSON.parse(@query.to_json)['filter'].should ==  {"fields" => [
+      {"type"=>"selector", "dimension"=>"a", "value"=>1},
+      {"type"=>"selector", "dimension"=>"a", "value"=>2},
+      {"type"=>"selector", "dimension"=>"a", "value"=>3}
+    ],
+    "type" => "or"}
+  end
+
+  it 'creates a javascript with > filter' do
+    @query.filter{a > 100}
+    JSON.parse(@query.to_json)['filter'].should == {
+      "type" => "javascript",
+      "dimension" => "a",
+      "function" => "function(a) { return(a > 100); }"
+    }
+  end
+
+  it 'creates a mixed javascript filter' do
+    @query.filter{(a >= 128) & (a != 256)}
+    JSON.parse(@query.to_json)['filter'].should == {"fields" => [
+      {"type" => "javascript", "dimension" => "a", "function" => "function(a) { return(a >= 128); }"},
+      {"field" => {"type" => "selector", "dimension" => "a", "value" => 256}, "type" => "not"}
+    ],
+    "type" => "and"}
+  end
+
+  it 'creates a complex javascript filter' do
+    @query.filter{(a >= 4) & (a <= '128')}
+    JSON.parse(@query.to_json)['filter'].should == {"fields" => [
+      {"type" => "javascript", "dimension" => "a", "function" => "function(a) { return(a >= 4); }"},
+      {"type" => "javascript", "dimension" => "a", "function" => "function(a) { return(a <= '128'); }"}
+    ],
+    "type" => "and"}
+  end
+
+  it 'can chain two in statements' do
+    @query.filter{a.in([1,2,3]) & b.in([1,2,3])}
+    JSON.parse(@query.to_json)['filter'].should == {"type"=>"and", "fields"=>[
+      {"type"=>"or", "fields"=>[
+        {"type"=>"selector", "dimension"=>"a", "value"=>1},
+        {"type"=>"selector", "dimension"=>"a", "value"=>2},
+        {"type"=>"selector", "dimension"=>"a", "value"=>3}
+      ]},
+      {"type"=>"or", "fields"=>[
+        {"type"=>"selector", "dimension"=>"b", "value"=>1},
+        {"type"=>"selector", "dimension"=>"b", "value"=>2},
+        {"type"=>"selector", "dimension"=>"b", "value"=>3}
+      ]}
+    ]}
+  end
+
+  it 'creates a greater than having clause' do
+    @query.having{a > 100}
+    JSON.parse(@query.to_json)['having'].should == {
+      "type"=>"greaterThan", "aggregation"=>"a", "value"=>100
+    }
+  end
+
+  it 'does not accept in with empty array' do
+    expect { @query.filter{a.in []} }.to raise_error "Must provide non-empty array in in()"
+  end
+
+  it 'does raise on invalid filter statement' do
+    expect { @query.filter{:a} }.to raise_error 'Not a valid filter'
+  end
+
+  it 'raises if no value is passed to a filter operator' do
+    expect { @query.filter{a.eq a}.to_json}.to raise_error 'no value assigned'
+  end
+
+  it 'raises wrong number of arguments if  filter operator is called without param' do
+    expect { @query.filter{a.eq}.to_json}.to raise_error 'wrong number of arguments (0 for 1)'
+  end
+
+  it 'should query regexp using .regexp(string)' do
+    JSON.parse(@query.filter{a.regexp('[1-9].*')}.to_json)['filter'].should == {
+      "dimension"=>"a",
+      "type"=>"regex",
+      "pattern"=>"[1-9].*"
+    }
+  end
+
+  it 'should query regexp using .eq(regexp)' do
+    JSON.parse(@query.filter{a.in(/abc.*/)}.to_json)['filter'].should == {
+      "dimension"=>"a",
+      "type"=>"regex",
+      "pattern"=>"abc.*"
+    }
+  end
+
+  it 'should query regexp using .in([regexp])' do
+    JSON.parse(@query.filter{ a.in(['b', /[a-z].*/, 'c']) }.to_json)['filter'].should == {
+      "type"=>"or",
+      "fields"=>[
+        {"dimension"=>"a", "type"=>"selector", "value"=>"b"},
+        {"dimension"=>"a", "type"=>"regex", "pattern"=>"[a-z].*"},
+        {"dimension"=>"a", "type"=>"selector", "value"=>"c"}
+      ]
+    }
+  end
+
+end