ruby-druid 0.1.9 → 0.9.0

data/lib/druid/version.rb

@@ -0,0 +1,3 @@
+module Druid
+  VERSION = "0.9.0"
+end

data/lib/druid/zk.rb

@@ -0,0 +1,141 @@
+require 'zk'
+require 'multi_json'
+require 'rest_client'
+
+module Druid
+  class ZK
+    def initialize(uri, opts = {})
+      @zk = ::ZK.new(uri, chroot: :check)
+      @registry = Hash.new { |hash, key| hash[key] = Array.new }
+      @discovery_path = opts[:discovery_path] || '/discovery'
+      @watched_services = Hash.new
+      register
+    end
+
+    def register
+      $log.info("druid.zk register discovery path") if $log
+      @zk.on_expired_session { register }
+      @zk.register(@discovery_path, only: :child) do |event|
+        $log.info("druid.zk got event on discovery path") if $log
+        check_services
+      end
+      check_services
+    end
+
+    def close!
+      $log.info("druid.zk shutting down") if $log
+      @zk.close!
+    end
+
+    def register_service(service, brokers)
+      $log.info("druid.zk register", service: service, brokers: brokers) if $log
+      # poor mans load balancing
+      @registry[service] = brokers.shuffle
+    end
+
+    def unregister_service(service)
+      $log.info("druid.zk unregister", service: service) if $log
+      @registry.delete(service)
+      unwatch_service(service)
+    end
+
+    def watch_service(service)
+      return if @watched_services.include?(service)
+      $log.info("druid.zk watch", service: service) if $log
+      watch = @zk.register(watch_path(service), only: :child) do |event|
+        $log.info("druid.zk got event on watch path for", service: service, event: event) if $log
+        unwatch_service(service)
+        check_service(service)
+      end
+      @watched_services[service] = watch
+    end
+
+    def unwatch_service(service)
+      return unless @watched_services.include?(service)
+      $log.info("druid.zk unwatch", service: service) if $log
+      @watched_services.delete(service).unregister
+    end
+
+    def check_services
+      $log.info("druid.zk checking services") if $log
+      zk_services = @zk.children(@discovery_path, watch: true)
+
+      (services - zk_services).each do |service|
+        unregister_service(service)
+      end
+
+      zk_services.each do |service|
+        check_service(service)
+      end
+    end
+
+    def verify_broker(service, name)
+      $log.info("druid.zk verify", broker: name, service: service) if $log
+      info = @zk.get("#{watch_path(service)}/#{name}")
+      node = MultiJson.load(info[0])
+      uri = "http://#{node['address']}:#{node['port']}/druid/v2/"
+      check = RestClient::Request.execute({
+        method: :get, url: "#{uri}datasources/",
+        timeout: 5, open_timeout: 5
+      })
+      $log.info("druid.zk verified", uri: uri, sources: check) if $log
+      return [uri, MultiJson.load(check.to_str)] if check.code == 200
+    rescue
+      return false
+    end
+
+    def watch_path(service)
+      "#{@discovery_path}/#{service}"
+    end
+
+    def check_service(service)
+      return if @watched_services.include?(service)
+
+      watch_service(service)
+
+      known = @registry[service].map { |node| node[:name] }
+      live = @zk.children(watch_path(service), watch: true)
+      new_list = @registry[service].select { |node| live.include?(node[:name]) }
+      $log.info("druid.zk checking", service: service, known: known, live: live, new_list: new_list) if $log
+
+      # verify the new entries to be living brokers
+      (live - known).each do |name|
+        uri, sources = verify_broker(service, name)
+        new_list.push({ name: name, uri: uri, data_sources: sources }) if uri
+      end
+
+      if new_list.empty?
+        # don't show services w/o active brokers
+        unregister_service(service)
+      else
+        register_service(service, new_list)
+      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

@@ -1,20 +1,32 @@
-# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$:.unshift(lib) unless $:.include?(lib)
+
+require "druid/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "ruby-druid"
-  spec.version       = "0.1.9"
-  spec.authors       = ["LiquidM, Inc."]
-  spec.email         = ["opensource@liquidm.com"]
-  spec.summary       = %q{Ruby client for metamx druid}
-  spec.description   = %q{Ruby client for metamx druid}
-  spec.homepage      = "https://github.com/liquidm/ruby-druid"
+  spec.version       = Druid::VERSION
+  spec.authors       = ["Ruby Druid Community"]
+  spec.summary       = %q{A Ruby client for Druid}
+  spec.description   = <<-EOF
+    ruby-druid is a Ruby client for Druid. It includes a Squeel-like query DSL
+    and generates a JSON query that can be sent to Druid directly.
+  EOF
+  spec.homepage      = "https://github.com/ruby-druid/ruby-druid"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = Dir["lib/**/*"] + %w{LICENSE README.md ruby-druid.gemspec}
+  spec.test_files = Dir["spec/**/*"]
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "zk"
-  spec.add_dependency "rest-client"
+  spec.add_dependency "activesupport", "~> 4.2"
+  spec.add_dependency "activemodel", "~> 4.2"
+  spec.add_dependency "iso8601", "~> 0.9"
+  spec.add_dependency "multi_json", "~> 1.12"
+  spec.add_dependency "rest-client", "~> 2.0"
+  spec.add_dependency "zk", "~> 1.9"
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 11.2"
+  spec.add_development_dependency "rspec", "~> 3.4"
+  spec.add_development_dependency "webmock", "~> 2.1"
 end

data/spec/lib/client_spec.rb

@@ -1,67 +1,20 @@
 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(double(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(double(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(double(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(double(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"]
+    expect(Druid::ZK).to receive(:new).with('test_uri', {})
+    Druid::Client.new('test_uri')
+  end
+
+  it 'returns the correct data source' do
+    stub_request(:get, "http://www.example.com/druid/v2/datasources/test").
+      with(:headers => { 'Accept'=>'*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'User-Agent' => 'Ruby' }).
+      to_return(:status => 200, :body => "{\"dimensions\":[\"d1\", \"d2\"], \"metrics\":[\"m1\", \"m2\"]}", :headers => {})
+    expect(Druid::ZK).to receive(:new).and_return(double(Druid::ZK, :data_sources => { 'test/test' => 'http://www.example.com/druid/v2/' }, :close! => true))
+    client = Druid::Client.new('test_uri')
+    ds = client.data_source('test/test')
+    expect(ds.name).to eq('test')
+    expect(ds.metrics).to eq(['m1', 'm2'])
+    expect(ds.dimensions).to eq(['d1', 'd2'])
   end
 
 end

data/spec/lib/data_source_spec.rb

@@ -0,0 +1,65 @@
+describe Druid::DataSource do
+
+  context '#post' do
+    it 'parses response on 200' do
+      # MRI
+      stub_request(:post, "http://www.example.com/druid/v2").
+        with(:body => "{\"context\":{\"queryId\":null},\"queryType\":\"timeseries\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"],\"granularity\":\"all\",\"dataSource\":\"test\"}",
+          :headers => { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type' => 'application/json', 'User-Agent' => 'Ruby' }).
+        to_return(:status => 200, :body => '[]', :headers => {})
+      # JRuby ... *sigh
+      stub_request(:post, "http://www.example.com/druid/v2").
+        with(:body => "{\"context\":{\"queryId\":null},\"granularity\":\"all\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"],\"queryType\":\"timeseries\",\"dataSource\":\"test\"}",
+          :headers => { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type' => 'application/json', 'User-Agent' => 'Ruby' }).
+        to_return(:status => 200, :body => '[]', :headers => {})
+      ds = Druid::DataSource.new('test/test', 'http://www.example.com/druid/v2')
+      query = Druid::Query::Builder.new.interval('2013-04-04', '2013-04-04').granularity(:all).query
+      query.context.queryId = nil
+      expect(ds.post(query)).to be_empty
+    end
+
+    it 'raises on request failure' do
+      # MRI
+      stub_request(:post, 'http://www.example.com/druid/v2').
+        with(:body => "{\"context\":{\"queryId\":null},\"queryType\":\"timeseries\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"],\"granularity\":\"all\",\"dataSource\":\"test\"}",
+          :headers => { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type' => 'application/json', 'User-Agent' => 'Ruby' }).
+        to_return(:status => 666, :body => 'Strange server error', :headers => {})
+      # JRuby ... *sigh
+      stub_request(:post, 'http://www.example.com/druid/v2').
+        with(:body => "{\"context\":{\"queryId\":null},\"granularity\":\"all\",\"intervals\":[\"2013-04-04T00:00:00+00:00/2013-04-04T00:00:00+00:00\"],\"queryType\":\"timeseries\",\"dataSource\":\"test\"}",
+          :headers => { 'Accept' => '*/*', 'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3', 'Content-Type' => 'application/json', 'User-Agent' => 'Ruby' }).
+        to_return(:status => 666, :body => 'Strange server error', :headers => {})
+      ds = Druid::DataSource.new('test/test', 'http://www.example.com/druid/v2')
+      query = Druid::Query::Builder.new.interval('2013-04-04', '2013-04-04').granularity(:all).query
+      query.context.queryId = nil
+      expect { ds.post(query) }.to raise_error(Druid::DataSource::Error)
+    end
+  end
+
+  context '#metadata' do
+    it 'parses metrics on 200' do
+      stub_request(:get, 'http://www.example.com/druid/v2/datasources/test').
+        to_return(:status => 200, :body => '{}', :headers => {})
+      ds = Druid::DataSource.new('test/test', 'http://www.example.com/druid/v2/')
+      expect(ds.metrics).to be_nil
+    end
+
+    it 'raises on request failure' do
+      stub_request(:get, 'http://www.example.com/druid/v2/datasources/test').
+        to_return(:status => 666, :body => 'Strange server error', :headers => {})
+      ds = Druid::DataSource.new('test/test', 'http://www.example.com/druid/v2/')
+      expect { ds.metrics }.to raise_error(RuntimeError)
+    end
+  end
+
+  context '#metadata!' do
+    it 'includes interval in metadata request' do
+      stub = stub_request(:get, 'http://www.example.com/druid/v2/datasources/test?interval=2015-04-10T00:00:00+00:00/2015-04-17T00:00:00+00:00').
+        to_return(:status => 200, :body => '{}', :headers => {})
+      ds = Druid::DataSource.new('test/test', 'http://www.example.com/druid/v2/')
+      ds.metadata!(:interval => ['2015-04-10', '2015-04-17'])
+      expect(stub).to have_been_requested
+    end
+  end
+
+end

data/spec/lib/query_spec.rb

@@ -1,142 +1,137 @@
 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'
+    @query = Druid::Query::Builder.new
   end
 
   it 'takes a query type' do
     @query.query_type('query_type')
-    JSON.parse(@query.to_json)['queryType'].should == 'query_type'
+    expect(JSON.parse(@query.query.to_json)['queryType']).to eq('query_type')
   end
 
   it 'sets query type by group_by' do
-    @query.group_by()
-    JSON.parse(@query.to_json)['queryType'].should == 'groupBy'
+    @query.group_by
+    expect(JSON.parse(@query.query.to_json)['queryType']).to eq('groupBy')
   end
 
   it 'sets query type to timeseries' do
-    @query.time_series()
-    JSON.parse(@query.to_json)['queryType'].should == 'timeseries'
+    @query.timeseries
+    expect(JSON.parse(@query.query.to_json)['queryType']).to eq('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']
+    expect(JSON.parse(@query.query.to_json)['dimensions']).to eq(['a', 'b', 'c'])
   end
 
   it 'takes dimension, metric and threshold from topn method' do
     @query.topn(:a, :b, 25)
-    result = JSON.parse(@query.to_json)
-    result['dimension'].should == 'a'
-    result['metric'].should == 'b'
-    result['threshold'].should == 25
+    result = JSON.parse(@query.query.to_json)
+    expect(result['dimension']).to eq('a')
+    expect(result['metric']).to eq('b')
+    expect(result['threshold']).to eq(25)
   end
 
   describe '#postagg' do
     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",
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([{"type"=>"arithmetic",
         "fn"=>"+",
         "fields"=>
-        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
+        [{"type"=>"fieldAccess", "fieldName"=>"a"},
          {"type"=>"constant", "value"=>1}],
-        "name"=>"ctr"}]
+        "name"=>"ctr"}])
     end
 
     it 'build a + post aggregation' do
       @query.postagg{(a + b).as ctr }
-      JSON.parse(@query.to_json)['postAggregations'].should == [{"type"=>"arithmetic",
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([{"type"=>"arithmetic",
         "fn"=>"+",
         "fields"=>
-        [{"type"=>"fieldAccess","name"=>"a", "fieldName"=>"a"},
-        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
-        "name"=>"ctr"}]
+        [{"type"=>"fieldAccess", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "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",
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([{"type"=>"arithmetic",
         "fn"=>"-",
         "fields"=>
-        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
-        "name"=>"ctr"}]
+        [{"type"=>"fieldAccess", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "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",
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([{"type"=>"arithmetic",
         "fn"=>"*",
         "fields"=>
-        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
-        "name"=>"ctr"}]
+        [{"type"=>"fieldAccess", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "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",
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([{"type"=>"arithmetic",
         "fn"=>"/",
         "fields"=>
-        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
-      "name"=>"ctr"}]
+        [{"type"=>"fieldAccess", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "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",
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([{"type"=>"arithmetic",
         "fn"=>"*",
         "fields"=>
         [{"type"=>"arithmetic", "fn"=>"/", "fields"=>
-          [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-           {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}]},
+          [{"type"=>"fieldAccess", "fieldName"=>"a"},
+           {"type"=>"fieldAccess", "fieldName"=>"b"}]},
         {"type"=>"constant", "value"=>1000}],
-      "name"=>"ctr"}]
+      "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 == [
+      expect(JSON.parse(@query.query.to_json)['aggregations']).to eq([
         {"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",
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([{"type"=>"arithmetic",
         "fn"=>"/",
         "fields"=>
-        [{"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"},
-        {"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"}],
+        [{"type"=>"fieldAccess", "fieldName"=>"a"},
+        {"type"=>"fieldAccess", "fieldName"=>"b"}],
       "name"=>"ctr"},
       {"type"=>"arithmetic",
         "fn"=>"/",
         "fields"=>
-        [{"type"=>"fieldAccess", "name"=>"b", "fieldName"=>"b"},
-        {"type"=>"fieldAccess", "name"=>"a", "fieldName"=>"a"}],
+        [{"type"=>"fieldAccess", "fieldName"=>"b"},
+        {"type"=>"fieldAccess", "fieldName"=>"a"}],
       "name"=>"rtc"}
-      ]
+      ])
     end
 
     it 'builds a javascript post aggregation' do
       @query.postagg { js('function(agg1, agg2) { return agg1 + agg2; }').as result }
-      JSON.parse(@query.to_json)['postAggregations'].should == [
+      expect(JSON.parse(@query.query.to_json)['postAggregations']).to eq([
         {
           'type' => 'javascript',
           'name' => 'result',
           'fieldNames' => ['agg1', 'agg2'],
           'function' => 'function(agg1, agg2) { return agg1 + agg2; }'
         }
-      ]
+      ])
     end
 
     it 'raises an error when an invalid javascript function is used' do
@@ -148,18 +143,75 @@ describe Druid::Query do
 
   it 'builds aggregations on long_sum' do
     @query.long_sum(:a, :b, :c)
-    JSON.parse(@query.to_json)['aggregations'].should == [
+    expect(JSON.parse(@query.query.to_json)['aggregations']).to eq([
       { 'type' => 'longSum', 'name' => 'a', 'fieldName' => 'a'},
       { 'type' => 'longSum', 'name' => 'b', 'fieldName' => 'b'},
       { 'type' => 'longSum', 'name' => 'c', 'fieldName' => 'c'}
-    ]
+    ])
+  end
+
+  describe '#min' do
+    it 'builds aggregations with "min" type' do
+      @query.min(:a, :b)
+      expect(JSON.parse(@query.query.to_json)['aggregations']).to eq [
+        { 'type' => 'min', 'name' => 'a', 'fieldName' => 'a'},
+        { 'type' => 'min', 'name' => 'b', 'fieldName' => 'b'}
+      ]
+    end
+  end
+
+  describe '#max' do
+    it 'builds aggregations with "max" type' do
+      @query.max(:a, :b)
+      expect(JSON.parse(@query.query.to_json)['aggregations']).to eq [
+        { 'type' => 'max', 'name' => 'a', 'fieldName' => 'a'},
+        { 'type' => 'max', 'name' => 'b', 'fieldName' => 'b'}
+      ]
+    end
+  end
+
+  describe '#hyper_unique' do
+    it 'builds aggregation with "hyperUnique"' do
+      @query.hyper_unique(:a, :b)
+      expect(JSON.parse(@query.query.to_json)['aggregations']).to eq [
+        { 'type' => 'hyperUnique', 'name' => 'a', 'fieldName' => 'a'},
+        { 'type' => 'hyperUnique', 'name' => 'b', 'fieldName' => 'b'}
+      ]
+    end
+  end
+
+  describe '#cardinality' do
+    it 'builds aggregation with "cardinality" type' do
+      @query.cardinality(:a, [:dim1, :dim2], true)
+      expect(JSON.parse(@query.query.to_json)['aggregations']).to eq [
+        { 'type' => 'cardinality', 'name' => 'a', 'fieldNames' => ['dim1', 'dim2'], 'byRow' => true }
+      ]
+    end
+  end
+
+  describe '#js_aggregation' do
+    it 'builds aggregation with "javascript" type' do
+      @query.js_aggregation(:aggregate, [:x, :y],
+        aggregate: "function(current, a, b)      { return current + (Math.log(a) * b); }",
+        combine:   "function(partialA, partialB) { return partialA + partialB; }",
+        reset:     "function()                   { return 10; }"
+      )
+      expect(JSON.parse(@query.query.to_json)['aggregations']).to eq [{
+        'type' => 'javascript',
+        'name' => 'aggregate',
+        'fieldNames' => ['x', 'y'],
+        'fnAggregate' => 'function(current, a, b)      { return current + (Math.log(a) * b); }',
+        'fnCombine' =>   'function(partialA, partialB) { return partialA + partialB; }',
+        'fnReset' =>     'function()                   { return 10; }'
+      }]
+    end
   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 == [
+    expect(JSON.parse(@query.query.to_json)['aggregations'].sort{|x,y| x['name'] <=> y['name']}).to eq([
       { 'type' => 'longSum', 'name' => 'a', 'fieldName' => 'a'},
       { 'type' => 'longSum', 'name' => 'b', 'fieldName' => 'b'},
       { 'type' => 'longSum', 'name' => 'c', 'fieldName' => 'c'},
@@ -168,21 +220,21 @@ describe Druid::Query do
       { '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 == [
+    expect(JSON.parse(@query.query.to_json)['aggregations']).to eq([
       { 'type' => 'longSum', 'name' => 'a', 'fieldName' => 'a'},
       { 'type' => 'longSum', 'name' => 'b', 'fieldName' => 'b'},
-    ]
+    ])
   end
 
   it 'must be chainable' do
-    q = [Druid::Query.new('test')]
+    q = [Druid::Query::Builder.new]
     q.push q[-1].query_type('a')
     q.push q[-1].data_source('b')
     q.push q[-1].group_by('c')
@@ -193,274 +245,331 @@ describe Druid::Query do
     q.push q[-1].granularity(:day)
 
     q.each do |instance|
-      instance.should == q[0]
+      expect(instance).to eq(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']
+    @query.interval('2013-01-26T00', '2020-01-26T00:15')
+    expect(JSON.parse(@query.query.to_json)['intervals']).to eq(['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"]
+    @query.intervals([['2013-01-26T00', '2020-01-26T00:15'],['2013-04-23T00', '2013-04-23T15:00']])
+    expect(JSON.parse(@query.query.to_json)['intervals']).to eq(["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}"]
+    expect(JSON.parse(@query.query.to_json)['intervals']).to eq(["#{a.iso8601}/#{b.iso8601}"])
   end
 
   it 'takes a granularity from string' do
     @query.granularity('all')
-    JSON.parse(@query.to_json)['granularity'].should == 'all'
+    expect(JSON.parse(@query.query.to_json)['granularity']).to eq('all')
   end
 
   it 'should take a period' do
-    @query.granularity(:day, 'CEST')
-    @query.properties[:granularity].should == {
-      :type => "period",
-      :period => "P1D",
-      :timeZone => "Europe/Berlin"
-    }
-  end
+    @query.granularity("P1D", 'Europe/Berlin')
+    expect(@query.query.as_json['granularity']).to eq({
+      'type' => "period",
+      'period' => "P1D",
+      'timeZone' => "Europe/Berlin"
+    })
+  end
+
+  describe '#filter' do
+    it 'creates a in_circ filter' do
+      @query.filter{a.in_circ [[52.0,13.0], 10.0]}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({
+      "type" => "spatial",
+      "dimension" => "a",
+      "bound" => {
+          "type" => "radius",
+          "coords" => [52.0, 13.0],
+          "radius" =>  10.0
+        }
+      })
+    end
 
-  it 'creates a in_circ filter' do
-    @query.filter{a.in_circ [[52.0,13.0], 10.0]}
-    JSON.parse(@query.to_json)['filter'].should == {
-    "type" => "spatial",
-    "dimension" => "a",
-    "bound" => {
-        "type" => "radius",
-        "coords" => [52.0, 13.0],
-        "radius" =>  10.0
-      }
-    }
-  end
+    it 'creates a in_rec filter' do
+      @query.filter{a.in_rec [[10.0, 20.0], [30.0, 40.0]] }
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({
+      "type" => "spatial",
+      "dimension" => "a",
+      "bound" => {
+          "type" => "rectangular",
+          "minCoords" => [10.0, 20.0],
+          "maxCoords" => [30.0, 40.0]
+        }
+      })
+    end
 
-  it 'creates a in_rec filter' do
-    @query.filter{a.in_rec [[10.0, 20.0], [30.0, 40.0]] }
-    JSON.parse(@query.to_json)['filter'].should == {
-    "type" => "spatial",
-    "dimension" => "a",
-    "bound" => {
-        "type" => "rectangular",
-        "minCoords" => [10.0, 20.0],
-        "maxCoords" => [30.0, 40.0]
-      }
-    }
-  end
+    it 'creates an equals filter' do
+      @query.filter{a.eq 1}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({"type"=>"selector", "dimension"=>"a", "value"=>1})
+    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}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({"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}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"field" =>
+        {"type"=>"selector", "dimension"=>"a", "value"=>1},
+      "type" => "not"})
+    end
 
+    it 'creates a not filter with neq' do
+      @query.filter{a.neq 1}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"field" =>
+        {"type"=>"selector", "dimension"=>"a", "value"=>1},
+      "type" => "not"})
+    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 !=' do
+      @query.filter{a != 1}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"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 an and filter' do
+      @query.filter{a.neq(1) & b.eq(2) & c.eq('foo')}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"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 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 or filter' do
+      @query.filter{a.neq(1) | b.eq(2) | c.eq('foo')}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"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)}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"fields" => [
+        {"type"=>"selector", "dimension"=>"a", "value"=>1},
+        {"type"=>"selector", "dimension"=>"b", "value"=>2}
+      ],
+      "type" => "and"})
+    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 filter from hash' do
+      @query.filter a:1, b:2
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"fields" => [
+        {"type"=>"selector", "dimension"=>"a", "value"=>1},
+        {"type"=>"selector", "dimension"=>"b", "value"=>2}
+      ],
+      "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
+    context 'when type argument is :nin' do
+      it 'creates nin filter from hash' do
+        @query.filter({ a: 1, b: 2 }, :nin)
+        expect(JSON.parse(@query.query.to_json)['filter']).to eq({'fields' => [
+          {'type' => 'not', 'field' => { 'dimension' => 'a', 'type' => 'selector', 'value' => 1} },
+          {'type' => 'not', 'field' => { 'dimension' => 'b', 'type' => 'selector', 'value' => 2} }
+        ],
+        'type' => 'and'})
+      end
+    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 an in statement with or filter' do
+      @query.filter{a.in [1,2,3]}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"fields" => [
+        {"type"=>"selector", "dimension"=>"a", "value"=>1},
+        {"type"=>"selector", "dimension"=>"a", "value"=>2},
+        {"type"=>"selector", "dimension"=>"a", "value"=>3}
+      ],
+      "type" => "or"})
+    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"}
+    it 'creates a nin statement with and filter' do
+      @query.filter{a.nin [1,2,3]}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq( {"fields" => [
+        {"field"=>{"type"=>"selector", "dimension"=>"a", "value"=>1},"type" => "not"},
+        {"field"=>{"type"=>"selector", "dimension"=>"a", "value"=>2},"type" => "not"},
+        {"field"=>{"type"=>"selector", "dimension"=>"a", "value"=>3},"type" => "not"}
+      ],
+      "type" => "and"})
+    end
 
-  end
+    it 'creates a javascript with > filter' do
+      @query.filter{a > 100}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({
+        "type" => "javascript",
+        "dimension" => "a",
+        "function" => "function(a) { return(a > 100); }"
+      })
+    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 mixed javascript filter' do
+      @query.filter{(a >= 128) & (a != 256)}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({"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 nin statement with and filter' do
-    @query.filter{a.nin [1,2,3]}
-    JSON.parse(@query.to_json)['filter'].should ==  {"fields" => [
-      {"field"=>{"type"=>"selector", "dimension"=>"a", "value"=>1},"type" => "not"},
-      {"field"=>{"type"=>"selector", "dimension"=>"a", "value"=>2},"type" => "not"},
-      {"field"=>{"type"=>"selector", "dimension"=>"a", "value"=>3},"type" => "not"}
-    ],
-    "type" => "and"}
-  end
+    it 'creates a complex javascript filter' do
+      @query.filter{(a >= 4) & (a <= '128')}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({"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 '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 custom javascript filter' do
+      @query.filter{a.javascript("function(a) { return true; }")}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({
+        "type" => "javascript",
+        "dimension" => "a",
+        "function" => "function(a) { return true; }"
+      })
+    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"}
+    it 'can chain two in statements' do
+      @query.filter{a.in([1,2,3]) & b.in([1,2,3])}
+      expect(JSON.parse(@query.query.to_json)['filter']).to eq({"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
   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
+  describe '#having' do
+    subject(:having) { JSON.parse(@query.to_json)['having'] }
 
-  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 an equalTo clause using ==' do
+      @query.having { a == 100 }
+      expect(@query.query.as_json['having']).to eq({ 'type' => 'equalTo', 'aggregation' => 'a', 'value' => 100 })
+    end
 
-  describe '#having' do
-    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 'chains having clauses with and' do
-      @query.having{a > 100}.having{b > 200}.having{c > 300}
-      JSON.parse(@query.to_json)['having'].should == {
-        "type" => "and",
-        "havingSpecs" => [
-          { "type" => "greaterThan", "aggregation" => "a", "value" => 100 },
-          { "type" => "greaterThan", "aggregation" => "b", "value" => 200 },
-          { "type" => "greaterThan", "aggregation" => "c", "value" => 300 }
-        ]
-      }
+    it 'creates a not equalTo clause using !=' do
+      @query.having { a != 100 }
+      expect(@query.query.as_json['having']).to eq({
+        'type' => 'not',
+        'havingSpec' => { 'type' => 'equalTo', 'aggregation' => 'a', 'value' => 100 },
+      })
     end
-  end
 
-  it 'does not accept in with empty array' do
-    expect { @query.filter{a.in []} }.to raise_error "Values cannot be empty"
-  end
+    it 'creates a greaterThan clause using >' do
+      @query.having { a > 100 }
+      expect(@query.query.as_json['having']).to eq({ 'type' => 'greaterThan', 'aggregation' => 'a', 'value' => 100 })
+    end
 
-  it 'does raise on invalid filter statement' do
-    expect { @query.filter{:a} }.to raise_error 'Not a valid filter'
-  end
+    it 'creates a lessThan clause using <' do
+      @query.having { a < 100 }
+      expect(@query.query.as_json['having']).to eq({ 'type' => 'lessThan', 'aggregation' => 'a', 'value' => 100 })
+    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 'creates an add clause using &' do
+      @query.having { (a > 100) & (b > 200) }
+      expect(@query.query.as_json['having']).to eq({
+        'type' => 'and',
+        'havingSpecs' => [
+          { 'type' => 'greaterThan', 'aggregation' => 'a', 'value' => 100 },
+          { 'type' => 'greaterThan', 'aggregation' => 'b', 'value' => 200 },
+        ]
+      })
+    end
+
+    it 'creates an or clause using |' do
+      @query.having { (a > 100) | (b > 200) }
+      expect(@query.query.as_json['having']).to eq({
+        'type' => 'or',
+        'havingSpecs' => [
+          { 'type' => 'greaterThan', 'aggregation' => 'a', 'value' => 100 },
+          { 'type' => 'greaterThan', 'aggregation' => 'b', 'value' => 200 },
+        ]
+      })
+    end
+
+    it 'creates a not clause using !' do
+      @query.having { !((a == 100) & (b == 200)) }
+      expect(@query.query.as_json['having']).to eq({
+        'type' => 'not',
+        'havingSpec' => {
+          'type' => 'and',
+          'havingSpecs' => [
+            { 'type' => 'equalTo', 'aggregation' => 'a', 'value' => 100 },
+            { 'type' => 'equalTo', 'aggregation' => 'b', 'value' => 200 },
+          ]
+        }
+      })
+    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
+    it 'combines successive calls with and operator' do
+      @query.having { a > 100 }.having { b > 200 }.having { c > 300 }
+      expect(@query.query.as_json['having']).to eq({
+        'type' => 'and',
+        'havingSpecs' => [
+          { 'type' => 'greaterThan', 'aggregation' => 'a', 'value' => 100 },
+          { 'type' => 'greaterThan', 'aggregation' => 'b', 'value' => 200 },
+          { 'type' => 'greaterThan', 'aggregation' => 'c', 'value' => 300 },
+        ]
+      })
+    end
   end
 
   it 'should query regexp using .regexp(string)' do
-    JSON.parse(@query.filter{a.regexp('[1-9].*')}.to_json)['filter'].should == {
+    expect(JSON.parse(@query.filter{a.regexp('[1-9].*')}.query.to_json)['filter']).to eq({
       "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 == {
+    expect(JSON.parse(@query.filter{a.in(/abc.*/)}.query.to_json)['filter']).to eq({
       "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 == {
+    expect(JSON.parse(@query.filter{ a.in(['b', /[a-z].*/, 'c']) }.query.to_json)['filter']).to eq({
       "type"=>"or",
       "fields"=>[
         {"dimension"=>"a", "type"=>"selector", "value"=>"b"},
         {"dimension"=>"a", "type"=>"regex", "pattern"=>"[a-z].*"},
         {"dimension"=>"a", "type"=>"selector", "value"=>"c"}
       ]
-    }
+    })
   end
 
   it 'takes type, limit and columns from limit method' do
-    @query.limit_spec(10, :a => 'ASCENDING', :b => 'DESCENDING')
-    result = JSON.parse(@query.to_json)
-    result['limitSpec'].should == {
+    @query.limit(10, :a => 'ASCENDING', :b => 'DESCENDING')
+    result = JSON.parse(@query.query.to_json)
+    expect(result['limitSpec']).to eq({
       'type' => 'default',
       'limit' => 10,
       'columns' => [
         { 'dimension' => 'a', 'direction' => 'ASCENDING'},
         { 'dimension' => 'b', 'direction' => 'DESCENDING'}
       ]
-    }
+    })
   end
 end