ncs_mdes 0.11.0 → 0.12.0

data/spec/ncs_navigator/mdes/variable_spec.rb

@@ -230,6 +230,250 @@ XSD
       end
     end
 
+    describe '#diff' do
+      let(:a)      { Variable.new('A') }
+      let(:aprime) { Variable.new('A') }
+
+      let(:differences) { a.diff(aprime) }
+
+      describe 'name' do
+        it 'reports a difference when they are different' do
+          a.diff(Variable.new('B'))[:name].should be_a_value_diff('A', 'B')
+        end
+
+        it 'reports nothing when they are the same' do
+          differences.should be_nil
+        end
+      end
+
+      describe 'pii' do
+        it 'reports a difference when they are different' do
+          a.pii = true
+          aprime.pii = :possible
+
+          differences[:pii].should be_a_value_diff(true, :possible)
+        end
+
+        it 'reports nothing when they are the same' do
+          a.pii = :unknown
+          aprime.pii = :unknown
+
+          differences.should be_nil
+        end
+      end
+
+      describe 'status' do
+        let(:diff) { a.diff(aprime) }
+        let(:strict_diff) { a.diff(aprime, :strict => true) }
+
+        it 'reports nothing when they are the same' do
+          a.status = :active
+          aprime.status = :active
+
+          differences.should be_nil
+        end
+
+        loose_same =[
+          [     :new, :active],
+          [     :new, :modified],
+          [  :active, :modified],
+          [:modified, :active]
+        ]
+
+        loose_or_strict_different = [
+          [     :new, :retired],
+          [  :active, :retired],
+          [:modified, :retired],
+          ['a thing', :retired],
+
+          [     :new, 'some string'],
+          [  :active, 'some string'],
+          [:modified, 'some string'],
+          [ :retired, 'some string'],
+
+          [  :active, :new],
+          [:modified, :new],
+          [ :retired, :new],
+          ['a thing', :new],
+
+          [ :retired, :active],
+          ['a thing', :active],
+
+          [ :retired, :modified],
+          ['a thing', :modified],
+        ]
+
+        describe 'for a non-strict diff' do
+          loose_same.each do |left, right|
+            it "reports nothing for #{left.inspect} -> #{right.inspect}" do
+              a.status = left
+              aprime.status = right
+
+              diff.should be_nil
+            end
+          end
+
+          loose_or_strict_different.each do |left, right|
+            it "reports a difference for #{left.inspect} -> #{right.inspect}" do
+              a.status = left
+              aprime.status = right
+
+              diff[:status].should be_a_value_diff(left, right)
+            end
+          end
+        end
+
+        describe 'for a strict diff' do
+          (loose_same + loose_or_strict_different).each do |left, right|
+            it "reports a difference for #{left.inspect} -> #{right.inspect}" do
+              a.status = left
+              aprime.status = right
+
+              strict_diff[:status].should be_a_value_diff(left, right)
+            end
+          end
+        end
+      end
+
+      describe 'type' do
+        let(:type) { VariableType.new }
+        let(:typeprime) { VariableType.new }
+
+        before do
+          a.type = type
+          aprime.type = typeprime
+        end
+
+        describe 'when both have an anonymous type' do
+          it 'reports the differences when they are different' do
+            type.base_type = :int
+            typeprime.base_type = :string
+
+            differences[:type][:base_type].should be_a_value_diff(:int, :string)
+          end
+
+          it 'reports nothing for when they are the same' do
+            type.max_length = typeprime.max_length = 15
+
+            differences.should be_nil
+          end
+        end
+
+        describe 'when both have a named type' do
+          describe 'and the names differ' do
+            let(:type) { VariableType.new('f_oo').tap { |vt| vt.min_length = 10 } }
+            let(:typeprime) { VariableType.new('b_az') }
+
+            it 'reports the name difference' do
+              differences[:type][:name].should be_a_value_diff('f_oo', 'b_az')
+            end
+
+            it 'reports other differences' do
+              differences[:type][:min_length].should be_a_value_diff(10, nil)
+            end
+          end
+
+          # Motivation: a named type is resolved from the specification types
+          # collection. What's important at the point of this variable is that
+          # the type has changed; the details will be covered in the diff of
+          # the types. No need to repeat them for every variable that used that
+          # type
+          describe 'and the names are the same' do
+            let(:type) { VariableType.new('b_az').tap { |vt| vt.min_length = 10 } }
+            let(:typeprime) { VariableType.new('b_az') }
+
+            it 'does not report other differences' do
+              differences.should be_nil
+            end
+          end
+        end
+
+        describe 'when the left is named and the right is not' do
+          let(:type) { VariableType.new('b_ar').tap { |vt| vt.min_length = 5 } }
+          let(:typeprime) { VariableType.new.tap { |vt| vt.min_length = 6 } }
+
+          it 'reports the name difference' do
+            differences[:type][:name].should be_a_value_diff('b_ar', nil)
+          end
+
+          it 'reports the other differences' do
+            differences[:type][:min_length].should be_a_value_diff(5, 6)
+          end
+        end
+
+        describe 'when the right is named and the left is not' do
+          let(:type) { VariableType.new.tap { |vt| vt.min_length = 6 } }
+          let(:typeprime) { VariableType.new('b_ar').tap { |vt| vt.min_length = 5 } }
+
+          it 'reports the name difference' do
+            differences[:type][:name].should be_a_value_diff(nil, 'b_ar')
+          end
+
+          it 'reports the other differences' do
+            differences[:type][:min_length].should be_a_value_diff(6, 5)
+          end
+        end
+      end
+
+      describe 'omittable' do
+        it 'reports nothing when they are the same' do
+          a.omittable = false
+          aprime.omittable = nil
+
+          differences.should be_nil
+        end
+
+        it 'reports a difference when they are different' do
+          a.omittable = false
+          aprime.omittable = true
+
+          differences[:omittable?].should be_a_value_diff(false, true)
+        end
+      end
+
+      describe 'nillable' do
+        it 'reports nothing when they are the same' do
+          a.nillable = nil
+          aprime.nillable = false
+
+          differences.should be_nil
+        end
+
+        it 'reports a difference when they are different' do
+          a.nillable = true
+          aprime.nillable = false
+
+          differences[:nillable?].should be_a_value_diff(true, false)
+        end
+      end
+
+      describe 'table_reference' do
+        it 'reports nothing when they are the same' do
+          a.table_reference = TransmissionTable.new('Tb')
+          aprime.table_reference = TransmissionTable.new('Tb')
+
+          differences.should be_nil
+        end
+
+        it 'reports nothing when they are both nil' do
+          differences.should be_nil
+        end
+
+        it 'reports a change when one has a ref and the other does not' do
+          aprime.table_reference = TransmissionTable.new('Tc')
+
+          differences[:table_reference].should be_a_value_diff(nil, 'Tc')
+        end
+
+        it 'reports a change when the referenced table is different' do
+          a.table_reference = TransmissionTable.new('Ty')
+          aprime.table_reference = TransmissionTable.new('Tx')
+
+          differences[:table_reference].should be_a_value_diff('Ty', 'Tx')
+        end
+      end
+    end
+
     describe '#resolve_type!' do
       let(:reference_type) { VariableType.reference('ncs:color_cl3') }
       let(:actual_type)    { VariableType.new('color_cl3') }

data/spec/ncs_navigator/mdes/variable_type_spec.rb

@@ -149,65 +149,186 @@ module NcsNavigator::Mdes
         subject.should_not be_reference
       end
     end
-  end
 
-  describe VariableType::CodeListEntry do
-    describe '.from_xsd_enumeration' do
-      def code_list_entry(xml_s)
-        VariableType::CodeListEntry.from_xsd_enumeration(schema_element(xml_s), :log => logger)
-      end
+    describe '#diff' do
+      let(:a)      { VariableType.new('A') }
+      let(:aprime) { VariableType.new('A') }
 
-      let(:missing) {
-        code_list_entry(<<-XSD)
-          <xs:enumeration value="-4" ncsdoc:label="Missing in Error" ncsdoc:desc="" ncsdoc:global_value="99-4" ncsdoc:master_cl="missing_data"/>
-        XSD
-      }
+      let(:diff)        { a.diff(aprime) }
+      let(:strict_diff) { a.diff(aprime, :strict => true) }
 
-      describe '#value' do
-        it 'is set' do
-          missing.value.should == "-4"
-        end
+      it 'reports nothing when they are the same' do
+        diff.should be_nil
+      end
 
-        it 'warns when missing' do
-          code_list_entry('<xs:enumeration ncsdoc:label="Foo"/>')
-          logger[:warn].first.should == 'Missing value for code list entry on line 2'
+      describe 'name' do
+        it 'reports a difference' do
+          a.diff(VariableType.new('B'))[:name].should be_a_value_diff('A', 'B')
         end
+      end
 
-        describe 'with external whitespace on the value' do
-          let(:missing) {
-            code_list_entry(<<-XSD)
-              <xs:enumeration value="  -4 " ncsdoc:label="Missing in Error" ncsdoc:desc="" ncsdoc:global_value="99-4" ncsdoc:master_cl="missing_data"/>
-            XSD
-          }
+      describe 'base_type' do
+        it 'reports a difference' do
+          a.base_type = :int
+          aprime.base_type = :decimal
 
-          it 'removes the whitespace' do
-            missing.value.should == '-4'
-          end
+          diff[:base_type].should be_a_value_diff(:int, :decimal)
         end
       end
 
-      describe "#label" do
-        it 'is set' do
-          missing.label.should == "Missing in Error"
+      describe 'pattern' do
+        it 'reports a difference' do
+          a.pattern = /^(0-9){4}$/
+          aprime.pattern = /^(0-9){5}$/
+
+          diff[:pattern].should be_a_value_diff(/^(0-9){4}$/, /^(0-9){5}$/)
         end
       end
 
-      describe '#global_value' do
-        it 'is set' do
-          missing.global_value.should == '99-4'
+      describe 'max_length' do
+        it 'reports a difference' do
+          a.max_length = nil
+          aprime.max_length = 18
+
+          diff[:max_length].should be_a_value_diff(nil, 18)
         end
       end
 
-      describe '#master_cl' do
-        it 'is set' do
-          missing.master_cl.should == 'missing_data'
+      describe 'min_length' do
+        it 'reports a difference' do
+          a.min_length = 1
+          aprime.min_length = nil
+
+          diff[:min_length].should be_a_value_diff(1, nil)
         end
       end
-    end
 
-    describe '#to_s' do
-      it 'is the value' do
-        VariableType::CodeListEntry.new('14').to_s.should == '14'
+      describe 'code_list' do
+        let(:cl) { CodeList.new }
+        let(:clprime) { CodeList.new }
+
+        def cle(value, label)
+          CodeListEntry.new(value).tap { |e| e.label = label }
+        end
+
+        let(:e_one)         { cle( '1', 'Hand grenades')}
+        let(:e_five)        { cle( '5', 'Horseshoes') }
+        let(:e_other)       { cle('-5', 'Other') }
+        let(:e_other_prime) { cle( '5', 'Other') }
+
+        describe 'when only the left has a code list' do
+          before do
+            a.code_list = cl
+            cl << e_one << e_other
+          end
+
+          it 'reports all entries as left only by value' do
+            strict_diff[:code_list_by_value].left_only.should == %w(1 -5)
+          end
+
+          it 'reports all entries as left only by label' do
+            strict_diff[:code_list_by_label].left_only.should == ['Hand grenades', 'Other']
+          end
+        end
+
+        describe 'when only the right has a code list' do
+          before do
+            aprime.code_list = clprime
+            clprime << e_five << e_other
+          end
+
+          it 'reports all entries as right only by value' do
+            strict_diff[:code_list_by_value].right_only.should == %w(5 -5)
+          end
+
+          it 'reports all entries as right only by label' do
+            strict_diff[:code_list_by_label].right_only.should == ['Horseshoes', 'Other']
+          end
+        end
+
+        describe 'when both have code lists' do
+          before do
+            a.code_list = cl
+            aprime.code_list = clprime
+          end
+
+          describe 'and they are the same' do
+            before do
+              cl << e_one << e_five
+              clprime << e_one << e_five
+            end
+
+            it 'reports no differences' do
+              strict_diff.should be_nil
+            end
+          end
+
+          describe 'and they differ by values only' do
+            before do
+              cl << e_other << e_one
+              clprime << e_one << e_other_prime
+            end
+
+            it 'reports the entry difference in the by-label attribute' do
+              strict_diff[:code_list_by_label]['Other'][:value].
+                should be_a_value_diff('-5', '5')
+            end
+
+            it 'reports extra entries in the by-value attribute' do
+              strict_diff[:code_list_by_value].left_only.should == ['-5']
+              strict_diff[:code_list_by_value].right_only.should == ['5']
+            end
+          end
+
+          describe 'and they differ by labels only' do
+            before do
+              cl << e_one << e_five
+              clprime << e_one << e_other_prime
+            end
+
+            it 'reports the entry difference in the by-value attribute' do
+              strict_diff[:code_list_by_value]['5'][:label].
+                should be_a_value_diff('Horseshoes', 'Other')
+            end
+
+            it 'reports extra entries in the by-label attribute' do
+              strict_diff[:code_list_by_label].left_only.should == ['Horseshoes']
+              strict_diff[:code_list_by_label].right_only.should == ['Other']
+            end
+          end
+
+          describe 'and the differ by whitespace, punctuation and case in the labels only' do
+            let(:weird_left)  { '  foUR! ' }
+            let(:weird_right) { 'FOUR#' }
+
+            before do
+              cl << e_one << cle('4', weird_left)
+              clprime << e_one << cle('4', weird_right)
+            end
+
+            describe 'with a strict diff' do
+              it 'reports the entry difference in the by-value attribute' do
+                strict_diff[:code_list_by_value]['4'][:label].
+                  should be_a_value_diff(weird_left, weird_right)
+              end
+
+              it 'reports extra entries in the by-label attribute' do
+                strict_diff[:code_list_by_label].left_only.should == [weird_left]
+                strict_diff[:code_list_by_label].right_only.should == [weird_right]
+              end
+            end
+
+            describe 'with a loose diff' do
+              it 'reports no by-value differences' do
+                diff.should be_nil
+              end
+
+              it 'reports no by-label differences' do
+                diff.should be_nil
+              end
+            end
+          end
+        end
       end
     end
   end

data/spec/spec_helper.rb

@@ -4,7 +4,13 @@ require 'nokogiri'
 $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'ncs_navigator/mdes'
 
+module NcsNavigator::Mdes::Spec; end
+
+require 'differences_matchers'
+
 RSpec.configure do |config|
+  config.include(NcsNavigator::Mdes::Spec::Matchers)
+
   def logger
     @logger ||= NcsNavigator::Mdes::Spec::AccumulatingLogger.new
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ncs_mdes
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-20 00:00:00.000000000 Z
+date: 2013-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -117,31 +117,46 @@ files:
 - bin/mdes-console
 - ci-exec.sh
 - documents/1.2/Data_Transmission_Schema_V1.2.xsd
+- documents/1.2/child_or_parent_instrument_tables.yml
 - documents/1.2/heuristic_overrides.yml
 - documents/2.0/NCS_Transmission_Schema_2.0.01.02.xml
+- documents/2.0/child_or_parent_instrument_tables.yml
 - documents/2.0/disposition_codes.yml
 - documents/2.0/heuristic_overrides.yml
 - documents/2.1/NCS_Transmission_Schema_2.1.00.00.xsd
+- documents/2.1/child_or_parent_instrument_tables.yml
 - documents/2.1/disposition_codes.yml
 - documents/2.1/extract_disposition_codes.rb
 - documents/2.1/heuristic_overrides.yml
 - documents/2.2/NCS_Transmission_Schema_2.2.01.01.xsd
+- documents/2.2/child_or_parent_instrument_tables.yml
 - documents/2.2/disposition_codes.yml
 - documents/2.2/extract_disposition_codes.rb
 - documents/2.2/heuristic_overrides.yml
 - documents/3.0/NCS_Transmission_Schema_3.0.00.09.xsd
+- documents/3.0/child_or_parent_instrument_tables.yml
 - documents/3.0/disposition_codes.yml
 - documents/3.0/extract_disposition_codes.rb
 - documents/3.0/heuristic_overrides.yml
 - documents/3.1/NCS_Transmission_Schema_3.1.01.00.xsd
+- documents/3.1/child_or_parent_instrument_tables.yml
 - documents/3.1/disposition_codes.yml
 - documents/3.1/extract_disposition_codes.rb
 - documents/3.1/heuristic_overrides.yml
 - documents/3.2/NCS_Transmission_Schema_3.2.00.00.xsd
+- documents/3.2/child_or_parent_instrument_tables.yml
 - documents/3.2/disposition_codes.yml
 - documents/3.2/extract_disposition_codes.rb
 - documents/3.2/heuristic_overrides.yml
+- documents/scan_p_ids_for_children.rb
 - lib/ncs_navigator/mdes.rb
+- lib/ncs_navigator/mdes/code_list.rb
+- lib/ncs_navigator/mdes/differences.rb
+- lib/ncs_navigator/mdes/differences/collection.rb
+- lib/ncs_navigator/mdes/differences/collection_criterion.rb
+- lib/ncs_navigator/mdes/differences/entry.rb
+- lib/ncs_navigator/mdes/differences/value.rb
+- lib/ncs_navigator/mdes/differences/value_criterion.rb
 - lib/ncs_navigator/mdes/disposition_code.rb
 - lib/ncs_navigator/mdes/source_documents.rb
 - lib/ncs_navigator/mdes/specification.rb
@@ -150,6 +165,8 @@ files:
 - lib/ncs_navigator/mdes/variable_type.rb
 - lib/ncs_navigator/mdes/version.rb
 - ncs_mdes.gemspec
+- spec/differences_matchers.rb
+- spec/ncs_navigator/mdes/code_list_spec.rb
 - spec/ncs_navigator/mdes/disposition_code_spec.rb
 - spec/ncs_navigator/mdes/source_documents_spec.rb
 - spec/ncs_navigator/mdes/specification_spec.rb
@@ -173,7 +190,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1622356402615803316
+      hash: -1618062826933135286
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -182,14 +199,16 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1622356402615803316
+      hash: -1618062826933135286
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: A ruby API for various versions of the NCS MDES.
 test_files:
+- spec/differences_matchers.rb
+- spec/ncs_navigator/mdes/code_list_spec.rb
 - spec/ncs_navigator/mdes/disposition_code_spec.rb
 - spec/ncs_navigator/mdes/source_documents_spec.rb
 - spec/ncs_navigator/mdes/specification_spec.rb