conceptql 0.1.1 → 0.2.0

data/spec/conceptql/behaviors/dottable_spec.rb

@@ -1,74 +1,68 @@
 require 'spec_helper'
-require 'conceptql/nodes/node'
+require 'conceptql/operators/operator'
 require 'conceptql/behaviors/dottable'
 
-class NodeDouble < ConceptQL::Nodes::Node
+class OperatorDouble < ConceptQL::Operators::Operator
   include ConceptQL::Behaviors::Dottable
 
-  attr_accessor :values, :options
-  def initialize(*values)
-    @values = values
-    @options = {}
+  def initialize(*args)
+    super
     @types = []
   end
 end
 
 describe ConceptQL::Behaviors::Dottable do
   before do
-    @obj = NodeDouble.new
-    @obj.must_behave_like(:node)
+    @obj = OperatorDouble.new
   end
 
   describe '#display_name' do
-    it 'should show just the name if no children or arguments' do
+    it 'should show just the name if no upstreams or arguments' do
       @obj.values = []
-      @obj.display_name.must_equal 'Node Double'
+      expect(@obj.display_name).to match(/Operator Double( \d+)?/)
     end
 
     it 'should show name and args' do
       @obj.values = [5, 10]
-      @obj.display_name.must_equal 'Node Double: 5, 10'
+      expect(@obj.display_name).to match(/Operator Double( \d+)?: 5, 10/)
     end
 
-    it 'should not include children' do
-      @obj.values = [::ConceptQL::Nodes::Node.new]
-      @obj.display_name.must_equal 'Node Double'
+    it 'should not include upstreams' do
+      @obj.values = [::ConceptQL::Operators::Operator.new]
+      expect(@obj.display_name).to match(/Operator Double( \d+)?/)
     end
   end
 
-  describe '#node_name' do
-    it 'should show just the name and digit if no children' do
-      @obj.values = [::ConceptQL::Nodes::Node.new]
-      @obj.node_name.must_match(/^node_double_\d+$/)
+  describe '#operator_name' do
+    it 'should show just the name and digit if no upstreams' do
+      @obj.values = [::ConceptQL::Operators::Operator.new]
+      expect(@obj.operator_name).to match(/^operator_double_\d+$/)
     end
 
     it 'should not show args' do
       @obj.values = [5, 10]
-      @obj.node_name.must_match(/^node_double_\d+$/)
+      expect(@obj.operator_name).to match(/^operator_double_\d+$/)
     end
 
-    it 'should not include children' do
-      @obj.values = [::ConceptQL::Nodes::Node.new]
-      @obj.node_name.must_match(/^node_double_\d+$/)
+    it 'should not include upstreams' do
+      @obj.values = [::ConceptQL::Operators::Operator.new]
+      expect(@obj.operator_name).to match(/^operator_double_\d+$/)
     end
   end
 
   describe '#graph_it' do
-    it 'should add itself as a node if no children' do
+    it 'should add itself as a operator if no upstreams' do
       @obj.values = []
-      mock_graph = Minitest::Mock.new
-      mock_node = Minitest::Mock.new
-      mock_graph.expect :add_nodes, mock_node, [@obj.node_name]
-      mock_node.expect :[]=, nil, [:label, @obj.display_name]
-      mock_node.expect :[]=, nil, [:color, 'black']
+      mock_graph = double("graph")
+      mock_operator = double("operator")
+      expect(mock_graph).to receive(:add_nodes).with(@obj.operator_name).and_return(mock_operator)
+      expect(mock_operator).to receive(:[]=).with(:label, @obj.display_name).and_return(nil)
+      expect(mock_operator).to receive(:[]=).with(:color, 'black').and_return(nil)
       @obj.graph_it(mock_graph, Sequel.mock)
-
-      mock_node.verify
-      mock_graph.verify
     end
 
-    it 'should add its children, then link itself as a node if children' do
-      class MockChild < ConceptQL::Nodes::Node
+    it 'should add its upstreams, then link itself as a operator if upstreams' do
+      class MockUpstream < ConceptQL::Operators::Operator
         include ConceptQL::Behaviors::Dottable
 
         attr_accessor :mock
@@ -80,32 +74,26 @@ describe ConceptQL::Behaviors::Dottable do
           mock.types
         end
 
-        def link_to(mock_graph, mock_node, db)
-          mock.link_to(mock_graph, mock_node, db)
+        def link_to(mock_graph, mock_operator, db)
+          mock.link_to(mock_graph, mock_operator, db)
         end
       end
 
-      mock_node = Minitest::Mock.new
-      mock_node.expect :[]=, nil, [:label, @obj.display_name]
-      mock_node.expect :[]=, nil, [:color, 'black']
-
-      mock_graph = Minitest::Mock.new
-      mock_graph.expect :add_nodes, mock_node, [@obj.node_name]
+      mock_operator = double("operator")
+      expect(mock_operator).to receive(:[]=).with(:label, @obj.display_name).and_return(nil)
+      expect(mock_operator).to receive(:[]=).with(:color, 'black').and_return(nil)
 
-      mock_child = MockChild.new
-      mock_child.mock = Minitest::Mock.new
-      mock_child.mock.expect :graph_it, :child_node, [mock_graph, :db]
-      mock_child.mock.expect :link_to, nil, [mock_graph, mock_node, :db]
+      mock_graph = double("graph")
+      expect(mock_graph).to receive(:add_nodes).with(@obj.operator_name).and_return(mock_operator)
 
-      mock_child.must_behave_like(:node)
+      mock_upstream = MockUpstream.new
+      mock_upstream.mock = double("upstream")
+      expect(mock_upstream.mock).to receive(:graph_it).with(mock_graph, :db).and_return(:upstream_operator)
+      expect(mock_upstream.mock).to receive(:link_to).with(mock_graph, mock_operator, :db).and_return(nil)
 
-      @obj.values = [mock_child]
+      @obj.values = mock_upstream
 
       @obj.graph_it(mock_graph, :db)
-
-      mock_node.verify
-      mock_graph.verify
-      mock_child.mock.verify
     end
   end
 end

data/spec/conceptql/converter_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'conceptql/converter'
+
+describe ConceptQL::Converter do
+  describe '#convert' do
+    it 'convert {icd9: 412} to [:icd9, "412"]' do
+      statement = { icd9: '412' }
+      expect(ConceptQL::Converter.new.convert(statement)).to eq([:icd9, '412'])
+    end
+
+    it 'convert {icd9: ["412", "200"]} to [:icd9, "412"]' do
+      statement = { icd9: %w(412 200) }
+      expect(ConceptQL::Converter.new.convert(statement)).to eq([:icd9, '412', '200'])
+    end
+
+    it 'convert { first: {icd9: ["412", "200"]}} to [:first, [:icd9, "412"] ]' do
+      statement = {
+        first: {
+          icd9: %w(412 200)
+        }
+      }
+      expect(ConceptQL::Converter.new.convert(statement)).to eq([:first, [:icd9, '412', '200'] ])
+    end
+
+    it 'convert operators in options to list-syntax' do
+      statement = {
+        after: {
+          left: {
+            icd9: '412'
+          },
+          right: {
+            icd9: '200'
+
+          }
+        }
+      }
+      expect(ConceptQL::Converter.new.convert(statement)).to eq([:after, { left: [:icd9, '412'], right: [:icd9, '200'] }])
+    end
+
+    it 'converts operators with an array of upstreams' do
+      statement = {
+        intersect: [
+          { icd9: '412' },
+          { condition_type: :inpatient_header }
+        ]
+      }
+      expect(ConceptQL::Converter.new.convert(statement)).to eq([:intersect, [ :icd9, '412' ], [ :condition_type, :inpatient_header ] ])
+    end
+  end
+end
+

data/spec/conceptql/date_adjuster_spec.rb

@@ -4,63 +4,63 @@ require 'conceptql/date_adjuster'
 describe ConceptQL::DateAdjuster do
   describe '#adjustments' do
     it 'returns nothing for input of ""' do
-      ConceptQL::DateAdjuster.new('').adjustments.must_equal []
+      expect(ConceptQL::DateAdjuster.new('').adjustments).to eq([])
     end
 
     it 'returns nothing for input of "0"' do
-      ConceptQL::DateAdjuster.new('').adjustments.must_equal []
+      expect(ConceptQL::DateAdjuster.new('').adjustments).to eq([])
     end
 
     it 'returns nothing for input of nil' do
-      ConceptQL::DateAdjuster.new(nil).adjustments.must_equal []
+      expect(ConceptQL::DateAdjuster.new(nil).adjustments).to eq([])
     end
 
     it 'returns single day for input of "1"' do
-      ConceptQL::DateAdjuster.new('1').adjustments.must_equal [[:days, 1]]
+      expect(ConceptQL::DateAdjuster.new('1').adjustments).to eq([[:days, 1]])
     end
 
     it 'returns 20 days for input of "20"' do
-      ConceptQL::DateAdjuster.new('20').adjustments.must_equal [[:days, 20]]
+      expect(ConceptQL::DateAdjuster.new('20').adjustments).to eq([[:days, 20]])
     end
 
     it 'returns single day for input of "d"' do
-      ConceptQL::DateAdjuster.new('d').adjustments.must_equal [[:days, 1]]
+      expect(ConceptQL::DateAdjuster.new('d').adjustments).to eq([[:days, 1]])
     end
 
     it 'returns single month for input of "m"' do
-      ConceptQL::DateAdjuster.new('m').adjustments.must_equal [[:months, 1]]
+      expect(ConceptQL::DateAdjuster.new('m').adjustments).to eq([[:months, 1]])
     end
 
     it 'returns single year for input of "y"' do
-      ConceptQL::DateAdjuster.new('y').adjustments.must_equal [[:years, 1]]
+      expect(ConceptQL::DateAdjuster.new('y').adjustments).to eq([[:years, 1]])
     end
 
     it 'returns 2 days for input of "2d"' do
-      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal [[:days, 2]]
+      expect(ConceptQL::DateAdjuster.new('2d').adjustments).to eq([[:days, 2]])
     end
 
     it 'returns 2 months for input of "2m"' do
-      ConceptQL::DateAdjuster.new('2m').adjustments.must_equal [[:months, 2]]
+      expect(ConceptQL::DateAdjuster.new('2m').adjustments).to eq([[:months, 2]])
     end
 
     it 'returns 2 years for input of "2y"' do
-      ConceptQL::DateAdjuster.new('2y').adjustments.must_equal [[:years, 2]]
+      expect(ConceptQL::DateAdjuster.new('2y').adjustments).to eq([[:years, 2]])
     end
 
     it 'returns negative single day for input of "-d"' do
-      ConceptQL::DateAdjuster.new('-d').adjustments.must_equal [[:days, -1]]
+      expect(ConceptQL::DateAdjuster.new('-d').adjustments).to eq([[:days, -1]])
     end
 
     it 'returns negative single day, positive single month for "-dm"' do
-      ConceptQL::DateAdjuster.new('-dm').adjustments.must_equal [[:days, -1], [:months, 1]]
+      expect(ConceptQL::DateAdjuster.new('-dm').adjustments).to eq([[:days, -1], [:months, 1]])
     end
 
     it 'returns negative 2 days for "-2d"' do
-      ConceptQL::DateAdjuster.new('-2d').adjustments.must_equal [[:days, -2]]
+      expect(ConceptQL::DateAdjuster.new('-2d').adjustments).to eq([[:days, -2]])
     end
 
     it 'returns positive 2 days for "2d"' do
-      ConceptQL::DateAdjuster.new('2d').adjustments.must_equal [[:days, 2]]
+      expect(ConceptQL::DateAdjuster.new('2d').adjustments).to eq([[:days, 2]])
     end
   end
 end

data/spec/conceptql/operators/after_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'conceptql/operators/after'
+require_double('stream_for_temporal')
+
+describe ConceptQL::Operators::After do
+  it_behaves_like(:temporal_operator)
+
+  subject do
+    described_class.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new)
+  end
+
+  it 'should use proper where clause' do
+    expect(subject.query(Sequel.mock).sql).to match('l.start_date > r.end_date')
+  end
+end
+

data/spec/conceptql/operators/before_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'conceptql/operators/before'
+require_double('stream_for_temporal')
+
+describe ConceptQL::Operators::Before do
+  it_behaves_like(:temporal_operator)
+
+  subject do
+    described_class.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new)
+  end
+
+  it 'should use proper where clause' do
+    expect(subject.query(Sequel.mock).sql).to match('l.end_date < r.start_date')
+  end
+end
+

data/spec/conceptql/{nodes/casting_node_spec.rb → operators/casting_operator_spec.rb}

@@ -1,13 +1,11 @@
 require 'spec_helper'
-require 'conceptql/nodes/casting_node'
+require 'conceptql/operators/casting_operator'
 require_double('stream_for_casting')
 
-describe ConceptQL::Nodes::CastingNode do
-  it 'behaves itself' do
-    ConceptQL::Nodes::CastingNode.new.must_behave_like(:evaluator)
-  end
+describe ConceptQL::Operators::CastingOperator do
+  it_behaves_like(:evaluator)
 
-  class CastingDouble < ConceptQL::Nodes::CastingNode
+  class CastingDouble < ConceptQL::Operators::CastingOperator
     def my_type
       :my_type
     end
@@ -22,9 +20,7 @@ describe ConceptQL::Nodes::CastingNode do
   end
 
   describe CastingDouble do
-    it 'must behave' do
-      CastingDouble.new.must_behave_like(:casting_node)
-    end
+    it_behaves_like(:casting_operator)
   end
 
   describe '#query' do
@@ -32,39 +28,39 @@ describe ConceptQL::Nodes::CastingNode do
       stream = StreamForCastingDouble.new
       stream.types = [:uncastable]
       sql = CastingDouble.new(stream).query(Sequel.mock).sql
-      sql.must_match 'person_id IN'
-      sql.must_match 'GROUP BY person_id'
-      sql.must_match 'FROM table'
+      expect(sql).to match('person_id IN')
+      expect(sql).to match('GROUP BY person_id')
+      expect(sql).to match('FROM table')
     end
 
     it 'uses person_ids when an uncastable type is included among castable types' do
       stream = StreamForCastingDouble.new
       stream.types = [:i_point1, :uncastable]
       sql = CastingDouble.new(stream).query(Sequel.mock).sql
-      sql.must_match 'person_id IN'
-      sql.must_match 'GROUP BY person_id'
+      expect(sql).to match('person_id IN')
+      expect(sql).to match('GROUP BY person_id')
     end
 
     it 'uses castable types if possible' do
       stream = StreamForCastingDouble.new
       stream.types = [:i_point1]
       sql = CastingDouble.new(stream).query(Sequel.mock).sql
-      sql.must_match 'i_point1_id IN'
-      sql.must_match "criterion_type = 'i_point1'"
+      expect(sql).to match('i_point1_id IN')
+      expect(sql).to match("criterion_type = 'i_point1'")
     end
 
     it 'uses and unions multiple castable types if possible' do
       stream = StreamForCastingDouble.new
       stream.types = [:i_point1, :at_me2]
       sql = CastingDouble.new(stream).query(Sequel.mock).sql
-      sql.must_match 'my_type_id IN'
-      sql.must_match 'i_point1_id IN'
-      sql.must_match "criterion_type = 'i_point1'"
+      expect(sql).to match('my_type_id IN')
+      expect(sql).to match('i_point1_id IN')
+      expect(sql).to match("criterion_type = 'i_point1'")
     end
 
     it 'returns all rows of a table if passed the argument "true"' do
       sql = CastingDouble.new(true).query(Sequel.mock).sql
-      sql.must_match "SELECT * FROM my_type AS tab"
+      expect(sql).to match("SELECT * FROM my_type AS tab")
     end
   end
 end

data/spec/conceptql/operators/complement_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+require 'conceptql/operators/complement'
+require_relative 'query_double'
+
+describe ConceptQL::Operators::Complement do
+  it_behaves_like(:evaluator)
+
+  it 'generates complement for single criteria' do
+    double1 = QueryDouble.new(1)
+    sql = ConceptQL::Operators::Complement.new(double1).query(Sequel.mock).sql
+    expect(sql).to match("criterion_id IS NOT NULL")
+    expect(sql).to match("visit_occurrence_id NOT IN")
+    expect(sql).to match("criterion_type = 'visit_occurrence'")
+  end
+end

data/spec/conceptql/operators/concept_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'conceptql/operators/concept'
+
+describe ConceptQL::Operators::Concept do
+  it_behaves_like(:evaluator)
+
+  class ConceptDouble < ConceptQL::Operators::Concept
+    attr_accessor :cql_query
+
+    def arguments
+      [1]
+    end
+
+    def set_statement(value)
+      @statement = { icd9: '412' }
+    end
+
+    def set_cql_query(db)
+      @cql_query ||= nil
+    end
+
+    def cql_query
+      set_cql_query(nil)
+    end
+  end
+
+  describe '#query' do
+    it 'evaluates upstream' do
+      cd = ConceptDouble.new(1)
+      db = Sequel.mock
+      cd.cql_query = double("query")
+      expect(cd.cql_query).to receive(:query).and_return(cd.cql_query)
+      expect(cd.cql_query).to receive(:from_self)
+      cd.query(db)
+    end
+  end
+end
+
+
+

data/spec/conceptql/{nodes → operators}/condition_type_spec.rb

@@ -1,110 +1,125 @@
 require 'spec_helper'
-require 'conceptql/nodes/condition_type'
+require 'conceptql/operators/condition_type'
 
-describe ConceptQL::Nodes::ConditionType do
-  it 'behaves itself' do
-    ConceptQL::Nodes::ConditionType.new.must_behave_like(:evaluator)
-  end
+describe ConceptQL::Operators::ConditionType do
+  it_behaves_like(:evaluator)
 
   describe '#query' do
     it 'works for inpatient_detail_primary' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183))"
-      ConceptQL::Nodes::ConditionType.new(:inpatient_detail_primary).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:inpatient_detail_primary).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for inpatient_detail_1' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000184))"
-      ConceptQL::Nodes::ConditionType.new(:inpatient_detail_1).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:inpatient_detail_1).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for inpatient_detail_2' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000185))"
-      ConceptQL::Nodes::ConditionType.new(:inpatient_detail_2).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:inpatient_detail_2).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for inpatient_header_primary' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000199))"
-      ConceptQL::Nodes::ConditionType.new(:inpatient_header_primary).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:inpatient_header_primary).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for inpatient_header_1' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000200))"
-      ConceptQL::Nodes::ConditionType.new(:inpatient_header_1).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:inpatient_header_1).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for outpatient_detail_1' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000215))"
-      ConceptQL::Nodes::ConditionType.new(:outpatient_detail_1).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:outpatient_detail_1).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for outpatient_header_1' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000230))"
-      ConceptQL::Nodes::ConditionType.new(:outpatient_header_1).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:outpatient_header_1).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for ehr_problem_list' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000245))"
-      ConceptQL::Nodes::ConditionType.new(:ehr_problem_list).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:ehr_problem_list).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for condition_era_0_day_window' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000246))"
-      ConceptQL::Nodes::ConditionType.new(:condition_era_0_day_window).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:condition_era_0_day_window).query(Sequel.mock).sql).to eq(correct_query)
     end
 
     it 'works for condition_era_30_day_window' do
       correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000247))"
-      ConceptQL::Nodes::ConditionType.new(:condition_era_30_day_window).query(Sequel.mock).sql.must_equal correct_query
+      expect(ConceptQL::Operators::ConditionType.new(:condition_era_30_day_window).query(Sequel.mock).sql).to eq(correct_query)
+    end
+
+    describe 'with primary' do
+      it 'works for just primary' do
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183, 38000199, 38000215, 38000230))"
+        expect(ConceptQL::Operators::ConditionType.new(:primary).query(Sequel.mock).sql).to eq(correct_query)
+      end
+
+      it 'works for inpatient_primary' do
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183, 38000199))"
+        expect(ConceptQL::Operators::ConditionType.new(:inpatient_primary).query(Sequel.mock).sql).to eq(correct_query)
+      end
+
+      it 'works for outpatient_primary' do
+        correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000215, 38000230))"
+        expect(ConceptQL::Operators::ConditionType.new(:outpatient_primary).query(Sequel.mock).sql).to eq(correct_query)
+      end
     end
 
     describe 'with multiple arguments' do
       it 'works for inpatient_detail_1' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000184, 38000185))"
-        ConceptQL::Nodes::ConditionType.new(:inpatient_detail_1, :inpatient_detail_2).query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new(:inpatient_detail_1, :inpatient_detail_2).query(Sequel.mock).sql).to eq(correct_query)
       end
     end
 
     describe 'with arguments as strings' do
       it 'works for inpatient_detail_1' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000184, 38000185))"
-        ConceptQL::Nodes::ConditionType.new('inpatient_detail_1', 'inpatient_detail_2').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('inpatient_detail_1', 'inpatient_detail_2').query(Sequel.mock).sql).to eq(correct_query)
       end
     end
 
     describe 'as category' do
       it 'works for inpatient_detail' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183, 38000184, 38000185, 38000186, 38000187, 38000188, 38000189, 38000190, 38000191, 38000192, 38000193, 38000194, 38000195, 38000196, 38000197, 38000198))"
-        ConceptQL::Nodes::ConditionType.new('inpatient_detail').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('inpatient_detail').query(Sequel.mock).sql).to eq(correct_query)
       end
 
       it 'works for inpatient_header' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000199, 38000200, 38000201, 38000202, 38000203, 38000204, 38000205, 38000206, 38000207, 38000208, 38000209, 38000210, 38000211, 38000212, 38000213, 38000214))"
-        ConceptQL::Nodes::ConditionType.new('inpatient_header').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('inpatient_header').query(Sequel.mock).sql).to eq(correct_query)
       end
 
       it 'works for inpatient' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000183, 38000184, 38000185, 38000186, 38000187, 38000188, 38000189, 38000190, 38000191, 38000192, 38000193, 38000194, 38000195, 38000196, 38000197, 38000198, 38000199, 38000200, 38000201, 38000202, 38000203, 38000204, 38000205, 38000206, 38000207, 38000208, 38000209, 38000210, 38000211, 38000212, 38000213, 38000214))"
-        ConceptQL::Nodes::ConditionType.new('inpatient').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('inpatient').query(Sequel.mock).sql).to eq(correct_query)
       end
 
       it 'works for outpatient_detail' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000215, 38000216, 38000217, 38000218, 38000219, 38000220, 38000221, 38000222, 38000223, 38000224, 38000225, 38000226, 38000227, 38000228, 38000229))"
-        ConceptQL::Nodes::ConditionType.new('outpatient_detail').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('outpatient_detail').query(Sequel.mock).sql).to eq(correct_query)
       end
 
       it 'works for outpatient_header' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000230, 38000231, 38000232, 38000233, 38000234, 38000235, 38000236, 38000237, 38000238, 38000239, 38000240, 38000241, 38000242, 38000243, 38000244))"
-        ConceptQL::Nodes::ConditionType.new('outpatient_header').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('outpatient_header').query(Sequel.mock).sql).to eq(correct_query)
       end
 
       it 'works for outpatient' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000215, 38000216, 38000217, 38000218, 38000219, 38000220, 38000221, 38000222, 38000223, 38000224, 38000225, 38000226, 38000227, 38000228, 38000229, 38000230, 38000231, 38000232, 38000233, 38000234, 38000235, 38000236, 38000237, 38000238, 38000239, 38000240, 38000241, 38000242, 38000243, 38000244))"
-        ConceptQL::Nodes::ConditionType.new('outpatient').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('outpatient').query(Sequel.mock).sql).to eq(correct_query)
       end
 
       it 'works for condition_era' do
         correct_query = "SELECT * FROM condition_occurrence WHERE (condition_type_concept_id IN (38000246, 38000247))"
-        ConceptQL::Nodes::ConditionType.new('condition_era').query(Sequel.mock).sql.must_equal correct_query
+        expect(ConceptQL::Operators::ConditionType.new('condition_era').query(Sequel.mock).sql).to eq(correct_query)
       end
     end
   end

data/spec/conceptql/operators/contains_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'conceptql/operators/contains'
+require_double('stream_for_temporal')
+
+describe ConceptQL::Operators::Contains do
+  it_behaves_like(:temporal_operator)
+
+  describe 'when not inclusive' do
+    subject do
+      described_class.new(left: StreamForTemporalDouble.new, right: StreamForTemporalDouble.new)
+    end
+
+    it 'should use proper where clause' do
+      expect(subject.query(Sequel.mock).sql).to match('r.end_date <= l.end_date')
+      expect(subject.query(Sequel.mock).sql).to match('l.start_date <= r.start_date')
+    end
+  end
+end
+

data/spec/conceptql/operators/cpt_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'conceptql/operators/cpt'
+
+describe ConceptQL::Operators::Cpt do
+  it_behaves_like(:standard_vocabulary_operator)
+
+  subject do
+    described_class.new
+  end
+
+  describe '#table' do
+    it 'should be procedure_occurrence' do
+      expect(subject.table).to eq(:procedure_occurrence)
+    end
+  end
+
+  describe '#concept_column' do
+    it 'should be procedure_concept_id' do
+      expect(subject.concept_column).to eq(:procedure_concept_id)
+    end
+  end
+
+  describe '#vocabulary_id' do
+    it 'should be 4' do
+      expect(subject.vocabulary_id).to eq(4)
+    end
+  end
+end
+