mesh-medical-subject-headings 1.3.0 → 2.0.1

data/test/{mesh_test.rb → mesh_core_test.rb}

@@ -1,152 +1,153 @@
 require_relative 'test_helper'
 
 module MESH
-  describe 'Testing MESH:Mesh core functions' do
+  class MeshCoreTest < Minitest::Test
 
-    it 'should yield to a block for each' do
+    def test_yield_to_a_block_for_each
       block_called = false
-      MESH::Mesh.each do |h|
+      @mesh_tree.each do |h|
         block_called = true
         break
       end
       assert block_called
     end
 
-    it 'should not have nil headings' do
-      MESH::Mesh.each do |h|
+    def test_not_have_nil_headings
+      @mesh_tree.each do |h|
         refute_nil h
       end
     end
 
-    it 'should find by unique id' do
-      mh = MESH::Mesh.find('D000001')
+    def test_find_by_unique_id
+      mh = @mesh_tree.find('D000001')
       refute_nil mh
     end
 
-    it 'should find by tree number' do
-      mh = MESH::Mesh.find_by_tree_number('G14.640.079')
+    def test_find_by_tree_number
+      mh = @mesh_tree.find_by_tree_number('G14.640.079')
       refute_nil mh
       assert_equal 'D000065', mh.unique_id
     end
 
-    it 'should find by original heading' do
-      mh = MESH::Mesh.find_by_original_heading('Allergens')
+    def test_find_by_original_heading
+      mh = @mesh_tree.find_by_original_heading('Allergens')
       refute_nil mh
       assert_equal 'D000485', mh.unique_id
     end
 
-    it 'should not find original heading that doesnt exist' do
-      mh = MESH::Mesh.find_by_original_heading('Lorem')
+    def test_not_find_original_heading_that_doesnt_exist
+      mh = @mesh_tree.find_by_original_heading('Lorem')
       assert_nil mh
     end
 
-    it 'should have the correct unique id' do
-      mh = MESH::Mesh.find('D000001')
+    def test_have_the_correct_unique_id
+      mh = @mesh_tree.find('D000001')
       assert_equal 'D000001', mh.unique_id
     end
 
-    it 'should have the correct tree number' do
-      mh = MESH::Mesh.find('D000001')
+    def test_have_the_correct_tree_number
+      mh = @mesh_tree.find('D000001')
       assert_equal 1, mh.tree_numbers.length
       assert_includes mh.tree_numbers, 'D03.438.221.173'
     end
 
-    it 'should have the correct tree numbers' do
-      mh = MESH::Mesh.find('D000224')
+    def test_have_the_correct_tree_numbers
+      mh = @mesh_tree.find('D000224')
       assert_equal 2, mh.tree_numbers.length
       assert_includes mh.tree_numbers, 'C19.053.500.263'
       assert_includes mh.tree_numbers, 'C20.111.163'
     end
 
-    it 'should have the correct root letters' do
-      mh = MESH::Mesh.find('D000224')
+    def test_have_the_correct_root_letters
+      mh = @mesh_tree.find('D000224')
       assert_equal ['C'], mh.roots
-      mh = MESH::Mesh.find('D064946')
+      mh = @mesh_tree.find('D064946')
       assert_equal ['H', 'N'], mh.roots
     end
 
-    it 'should have the correct descriptor class' do
-      mh = MESH::Mesh.find('D000224')
+    def test_have_the_correct_descriptor_class
+      mh = @mesh_tree.find('D000224')
       assert_equal :topical_descriptor, mh.descriptor_class
-      mh = MESH::Mesh.find('D005260')
+      mh = @mesh_tree.find('D005260')
       assert_equal :check_tag, mh.descriptor_class
     end
 
-    it 'should have the correct original heading' do
-      mh = MESH::Mesh.find('D000224')
+    def test_have_the_correct_original_heading
+      mh = @mesh_tree.find('D000224')
       assert_equal 'Addison Disease', mh.original_heading
-      mh = MESH::Mesh.find('D000014')
+      mh = @mesh_tree.find('D000014')
       assert_equal 'Abnormalities, Drug-Induced', mh.original_heading
     end
 
-    it 'should have anglicised original heading' do
-      mh = MESH::Mesh.find('D001471')
+    def test_have_anglicised_original_heading
+      mh = @mesh_tree.find('D001471')
       assert_equal 'Barrett Esophagus', mh.original_heading
-      assert_equal 'Barrett Oesophagus', mh.original_heading('en-GB')
+      assert_equal 'Barrett Oesophagus', mh.original_heading(:en_gb)
     end
 
-    it 'should have natural language name' do
-      mh = MESH::Mesh.find('D000224')
+    def test_have_natural_language_name
+      mh = @mesh_tree.find('D000224')
       assert_equal 'Addison Disease', mh.natural_language_name
-      mh = MESH::Mesh.find('D000014')
+      mh = @mesh_tree.find('D000014')
       assert_equal 'Drug-Induced Abnormalities', mh.natural_language_name
     end
 
-    it 'should have anglicised natural language name' do
-      mh = MESH::Mesh.find('D001471')
+    def test_have_anglicised_natural_language_name
+      mh = @mesh_tree.find('D001471')
       assert_equal 'Barrett Esophagus', mh.natural_language_name
-      assert_equal 'Barrett Oesophagus', mh.natural_language_name('en-GB')
+      assert_equal 'Barrett Oesophagus', mh.natural_language_name(:en_gb)
     end
 
-    it 'should have the correct summary' do
-      mh = MESH::Mesh.find('D000238')
+    def test_have_the_correct_summary
+      mh = @mesh_tree.find('D000238')
       assert_equal 'A benign tumor of the anterior pituitary in which the cells do not stain with acidic or basic dyes.', mh.summary
     end
 
-    it 'should have anglicised summary' do
-      mh = MESH::Mesh.find('D001471')
+    def test_have_anglicised_summary
+      mh = @mesh_tree.find('D001471')
       assert_equal 'A condition with damage to the lining of the lower ESOPHAGUS resulting from chronic acid reflux (ESOPHAGITIS, REFLUX). Through the process of metaplasia, the squamous cells are replaced by a columnar epithelium with cells resembling those of the INTESTINE or the salmon-pink mucosa of the STOMACH. Barrett\'s columnar epithelium is a marker for severe reflux and precursor to ADENOCARCINOMA of the esophagus.', mh.summary
-      assert_equal 'A condition with damage to the lining of the lower OESOPHAGUS resulting from chronic acid reflux (OESOPHAGITIS, REFLUX). Through the process of metaplasia, the squamous cells are replaced by a columnar epithelium with cells resembling those of the INTESTINE or the salmon-pink mucosa of the STOMACH. Barrett\'s columnar epithelium is a marker for severe reflux and precursor to ADENOCARCINOMA of the oesophagus.', mh.summary('en-GB')
+      assert_equal 'A condition with damage to the lining of the lower OESOPHAGUS resulting from chronic acid reflux (OESOPHAGITIS, REFLUX). Through the process of metaplasia, the squamous cells are replaced by a columnar epithelium with cells resembling those of the INTESTINE or the salmon-pink mucosa of the STOMACH. Barrett\'s columnar epithelium is a marker for severe reflux and precursor to ADENOCARCINOMA of the oesophagus.', mh.summary(:en_gb)
     end
 
-    it 'should have the correct entries' do
+    def test_have_the_correct_entries
       expected_entries = ['Activity Cycles', 'Ultradian Cycles', 'Activity Cycle', 'Cycle, Activity', 'Cycle, Ultradian', 'Cycles, Activity', 'Cycles, Ultradian', 'Ultradian Cycle']
       expected_entries.sort!
-      mh = MESH::Mesh.find('D000204')
+      mh = @mesh_tree.find('D000204')
       assert_equal expected_entries, mh.entries
     end
 
-    it 'should have anglicised entries' do
+    def test_have_anglicised_entries
       expected_entries = ['Barrett Esophagus', 'Barrett Syndrome', 'Esophagus, Barrett', 'Barrett Epithelium', 'Barrett Metaplasia', 'Barrett\'s Esophagus', 'Barrett\'s Syndrome', 'Barretts Esophagus', 'Barretts Syndrome', 'Epithelium, Barrett', 'Esophagus, Barrett\'s', 'Syndrome, Barrett', 'Syndrome, Barrett\'s']
       expected_entries_en = ['Barrett Oesophagus', 'Barrett Syndrome', 'Oesophagus, Barrett', 'Barrett Epithelium', 'Barrett Metaplasia', 'Barrett\'s Oesophagus', 'Barrett\'s Syndrome', 'Barretts Oesophagus', 'Barretts Syndrome', 'Epithelium, Barrett', 'Oesophagus, Barrett\'s', 'Syndrome, Barrett', 'Syndrome, Barrett\'s']
+
       expected_entries.sort!
       expected_entries_en.sort!
-      mh = MESH::Mesh.find('D001471')
-      assert_equal expected_entries, mh.entries
-      assert_equal expected_entries_en, mh.entries('en-GB')
+      mh = @mesh_tree.find('D001471')
+      assert_equal expected_entries.sort, mh.entries
+      assert_equal expected_entries_en.sort, mh.entries(:en_gb)
     end
 
-    it 'should have the correct parent' do
-      mh = MESH::Mesh.find('D000001')
+    def test_have_the_correct_parent
+      mh = @mesh_tree.find('D000001')
       assert_equal 1, mh.parents.length
       assert_equal 'D001583', mh.parents[0].unique_id
     end
 
-    it 'should have the correct parents' do
-      mh = MESH::Mesh.find('D000224')
-      p1 = MESH::Mesh.find('D000309')
-      p2 = MESH::Mesh.find('D001327')
+    def test_have_the_correct_parents
+      mh = @mesh_tree.find('D000224')
+      p1 = @mesh_tree.find('D000309')
+      p2 = @mesh_tree.find('D001327')
       assert_equal 2, mh.parents.length
       assert_includes mh.parents, p1
       assert_includes mh.parents, p2
     end
 
-    it 'should have the correct children' do
-      parent = MESH::Mesh.find_by_tree_number('C19.053.500')
-      child1 = MESH::Mesh.find_by_tree_number('C19.053.500.263')
-      child2 = MESH::Mesh.find_by_tree_number('C19.053.500.270')
-      child3 = MESH::Mesh.find_by_tree_number('C19.053.500.480')
-      child4 = MESH::Mesh.find_by_tree_number('C19.053.500.740')
+    def test_have_the_correct_children
+      parent = @mesh_tree.find_by_tree_number('C19.053.500')
+      child1 = @mesh_tree.find_by_tree_number('C19.053.500.263')
+      child2 = @mesh_tree.find_by_tree_number('C19.053.500.270')
+      child3 = @mesh_tree.find_by_tree_number('C19.053.500.480')
+      child4 = @mesh_tree.find_by_tree_number('C19.053.500.740')
 
       assert_equal 4, parent.children.length
       assert_includes parent.children, child1
@@ -155,41 +156,41 @@ module MESH
       assert_includes parent.children, child4
     end
 
-    it 'should have the correct siblings' do
+    def test_have_the_correct_siblings
       skip
     end
 
-    it 'should match on conditions for original_heading' do
-      mh = MESH::Mesh.find('D001471')
+    def test_match_on_conditions_for_original_heading
+      mh = @mesh_tree.find('D001471')
       assert mh.matches(original_heading: /^Barrett Esophagus$/)
     end
 
-    it 'should not match on incorrect condition for original_heading' do
-      mh = MESH::Mesh.find('D001471')
+    def test_not_match_on_incorrect_condition_for_original_heading
+      mh = @mesh_tree.find('D001471')
       refute mh.matches(original_heading: /^Foo$/)
     end
 
-    it 'should match on conditions for entries' do
-      mh = MESH::Mesh.find('D001471')
+    def test_match_on_conditions_for_entries
+      mh = @mesh_tree.find('D001471')
       assert mh.matches(entries: /Metaplasia/)
     end
 
-    it 'should not match on incorrect conditions for entries' do
-      mh = MESH::Mesh.find('D001471')
+    def test_not_match_on_incorrect_conditions_for_entries
+      mh = @mesh_tree.find('D001471')
       refute mh.matches(entries: /Foo/)
     end
 
-    it 'should match on descriptor class' do
-      mh = MESH::Mesh.find('D000224')
+    def test_match_on_descriptor_class
+      mh = @mesh_tree.find('D000224')
       assert mh.matches(descriptor_class: :topical_descriptor)
       refute mh.matches(descriptor_class: :check_tag)
-      mh = MESH::Mesh.find('D005260')
+      mh = @mesh_tree.find('D005260')
       assert mh.matches(descriptor_class: :check_tag)
       refute mh.matches(descriptor_class: :topical_descriptor)
     end
 
-    it 'should match on conditions for tree numbers' do
-      mh = MESH::Mesh.find('D001471')
+    def test_match_on_conditions_for_tree_numbers
+      mh = @mesh_tree.find('D001471')
       assert mh.matches(tree_numbers: /C06\.198\.102/)
       assert mh.matches(tree_numbers: /^C06\.198\.102$/)
       assert mh.matches(tree_numbers: /^C06/)
@@ -197,23 +198,23 @@ module MESH
       assert mh.matches(tree_numbers: /^C06\.405\.117\.102$/)
     end
 
-    it 'should not match on incorrect conditions for tree numbers' do
-      mh = MESH::Mesh.find('D001471')
+    def test_not_match_on_incorrect_conditions_for_tree_numbers
+      mh = @mesh_tree.find('D001471')
       refute mh.matches(tree_numbers: /Foo/)
     end
 
-    it 'should match on conditions for summary' do
-      mh = MESH::Mesh.find('D001471')
+    def test_match_on_conditions_for_summary
+      mh = @mesh_tree.find('D001471')
       assert mh.matches(summary: /the lower ESOPHAGUS resulting from chronic acid reflux \(ESOPHAGITIS, REFLUX\)\./)
     end
 
-    it 'should not match on incorrect conditions for summary' do
-      mh = MESH::Mesh.find('D001471')
+    def test_not_match_on_incorrect_conditions_for_summary
+      mh = @mesh_tree.find('D001471')
       refute mh.matches(summary: /Foo/)
     end
 
-    it 'should match on conditions for useful' do
-      mh = MESH::Mesh.find('D001471')
+    def test_match_on_conditions_for_useful
+      mh = @mesh_tree.find('D001471')
       begin
         mh.useful = true
         assert mh.matches(useful: true)
@@ -226,88 +227,88 @@ module MESH
       end
     end
 
-    it 'should match on multiple conditions' do
-      mh = MESH::Mesh.find('D001471')
+    def test_match_on_multiple_conditions
+      mh = @mesh_tree.find('D001471')
       assert mh.matches(original_heading: /^Barrett Esophagus$/, summary: /the lower ESOPHAGUS/)
     end
 
-    it 'should not match on incorrect multiple conditions' do
-      mh = MESH::Mesh.find('D001471')
+    def test_not_match_on_incorrect_multiple_conditions
+      mh = @mesh_tree.find('D001471')
       refute mh.matches(original_heading: /^Barrett Esophagus$/, summary: /Foo/)
       refute mh.matches(original_heading: /^Foo/, summary: /the lower ESOPHAGUS/)
     end
 
-    it 'should match headings that occur in given text' do
+    def test_match_headings_that_occur_in_given_text
       expected_ids = %w(D001491 D001769 D001792 D001853 D002470 D002477 D002648 D002965 D002999 D003561 D003593 D003643 D004194 D004314 D004813 D004912 D005091 D005123 D005293 D005333 D005385 D005544 D005796 D006128 D006225 D006309 D006321 D006331 D006405 D007107 D007223 D007231 D007239 D007246 D007938 D007947 D008099 D008168 D008214 D008423 D008533 D008607 D008722 D009035 D009055 D009132 D009154 D009190 D009196 D009369 D009666 D010372 D010641 D011153 D012008 D012106 D012146 D012306 D012307 D012380 D012680 D012867 D013534 D013601 D013812 D013921 D013961 D014034 D014157 D014171 D014960 D015032 D015470 D015994 D015995 D016424 D016433 D017584 D017668 D018387 D018388 D019021 D019070 D019368 D019369 D032882 D036801 D038042 D041905 D052016 D054198 D055016)
-      expected = expected_ids.map { |id| MESH::Mesh.find(id) }
-      matches = MESH::Mesh.match_in_text(@example_text)
+      expected = expected_ids.map { |id| @mesh_tree.find(id) }
+      matches = @mesh_tree.match_in_text(@example_text)
       actual = matches.map { |match| match[:heading] }.uniq
       assert_equal expected.sort, actual.sort
     end
 
-    it 'should sort based on unique id' do
+    def test_sort_based_on_unique_id
       skip
     end
 
-    it 'should only match the most specific matches in given text' do
-      expected = MESH::Mesh.find('D054144')
-      actual = MESH::Mesh.match_in_text('Diastolic Heart Failure')
+    def test_only_match_the_most_specific_matches_in_given_text
+      expected = @mesh_tree.find('D054144')
+      actual = @mesh_tree.match_in_text('Diastolic Heart Failure')
       assert_equal 1, actual.length
       assert_equal expected, actual.first[:heading]
     end
 
-    it 'should only match useful headings that occur in given text' do
+    def test_only_match_useful_headings_that_occur_in_given_text
       expected_ids = %w(D001491 D001769 D001792 D001853 D002470 D002648 D002875 D002965 D003561 D003593 D003643 D004194 D004314 D004813 D004912 D005091 D005123 D005293 D005333 D005385 D005544 D005796 D006128 D006225 D006309 D006321 D006331 D006405 D007107 D007231 D007239 D007938 D007947 D008099 D008168 D008214 D008423 D008607 D008722 D009035 D009055 D009132 D009154 D009190 D009196 D009369 D009666 D010372 D010641 D011153 D012008 D012106 D012146 D012306 D012307 D012380 D012680 D012867 D013534 D013601 D013812 D013921 D013961 D014034 D014157 D014171 D015032 D015470 D015994 D015995 D016424 D017584 D017668 D018387 D018388 D019021 D019070 D019368 D019369 D032882 D036801 D038042 D041905 D052016 D054198)
 
       not_useful_ids = %w(D007246 D002477 D014960 D008533 D016433 D006664 D055016 D002999 D007223)
       begin
-        not_useful_ids.each { |id| MESH::Mesh.find(id).useful = false }
+        not_useful_ids.each { |id| @mesh_tree.find(id).useful = false }
 
-        expected = expected_ids.map { |id| MESH::Mesh.find(id) }
-        matches = MESH::Mesh.match_in_text(@example_text)
+        expected = expected_ids.map { |id| @mesh_tree.find(id) }
+        matches = @mesh_tree.match_in_text(@example_text)
         actual = matches.map { |match| match[:heading] }.uniq
         assert_equal expected, actual
       ensure
-        not_useful_ids.each { |id| MESH::Mesh.find(id).useful = true }
+        not_useful_ids.each { |id| @mesh_tree.find(id).useful = true }
       end
     end
 
-    it 'should match headings at start of text' do
+    def test_match_headings_at_start_of_text
       text = 'Leukemia, lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec pretium leo diam, quis adipiscing purus bibendum eu.'
-      matches = MESH::Mesh.match_in_text(text)
+      matches = @mesh_tree.match_in_text(text)
       assert_equal 1, matches.length
-      assert_equal MESH::Mesh.find('D007938'), matches[0][:heading]
+      assert_equal @mesh_tree.find('D007938'), matches[0][:heading]
     end
 
-    it 'should match headings at end of text' do
+    def test_match_headings_at_end_of_text
       text = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec pretium leo diam, quis adipiscing purus bibendum eu leukemia'
-      matches = MESH::Mesh.match_in_text(text)
+      matches = @mesh_tree.match_in_text(text)
       assert_equal 1, matches.length
-      assert_equal MESH::Mesh.find('D007938'), matches[0][:heading]
+      assert_equal @mesh_tree.find('D007938'), matches[0][:heading]
     end
 
-    it 'should return no matches when given nil text' do
-      assert_equal [], MESH::Mesh.match_in_text(nil)
+    def test_return_no_matches_when_given_nil_text
+      assert_equal [], @mesh_tree.match_in_text(nil)
     end
 
-    it 'should only match uppercase entries with uppercase text' do
+    def test_only_match_uppercase_entries_with_uppercase_text
       text = 'Lorem amet, consectetur adipiscing elit. Donec pretium ATP leo diam, quis adipiscing purus bibendum.'
-      matches = MESH::Mesh.match_in_text(text)
+      matches = @mesh_tree.match_in_text(text)
       assert_equal 1, matches.length
-      assert_equal MESH::Mesh.find('D000255'), matches[0][:heading]
+      assert_equal @mesh_tree.find('D000255'), matches[0][:heading]
       text = 'Lorem ipsum consectetur adipiscing elit. Donec pretium atp leo diam, quis adipiscing purus bibendum.'
-      assert_equal [], MESH::Mesh.match_in_text(text)
+      assert_equal [], @mesh_tree.match_in_text(text)
     end
 
-    it 'should match anglicised terms in text' do
+    def test_match_anglicised_terms_in_text
       text = 'Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec pretium leo diam, quis adipiscing purus bibendum eu leukaemia'
-      matches = MESH::Mesh.match_in_text(text)
+      matches = @mesh_tree.match_in_text(text)
       assert_equal 1, matches.length
-      assert_equal MESH::Mesh.find('D007938'), matches[0][:heading]
+      assert_equal @mesh_tree.find('D007938'), matches[0][:heading]
     end
 
-    it 'should allow headings to be marked as not useful' do
-      mh = MESH::Mesh.find('D055550')
+    def test_allow_headings_to_be_marked_as_not_useful
+      mh = @mesh_tree.find('D055550')
       mh.useful = true
       assert mh.useful
       mh.useful = false
@@ -316,91 +317,91 @@ module MESH
       assert mh.useful
     end
 
-    it 'should allow headings to be found with a where() match on original_heading' do
-      expected = [MESH::Mesh.find('D003561'), MESH::Mesh.find('D016238')]
-      actual = MESH::Mesh.where(original_heading: /^Cyta/)
+    def test_allow_headings_to_be_found_with_a_where_match_on_original_heading
+      expected = [@mesh_tree.find('D003561'), @mesh_tree.find('D016238')]
+      actual = @mesh_tree.where(original_heading: /^Cyta/)
       assert_equal expected, actual
     end
 
-    it 'should match on entries in where()' do
+    def test_match_on_entries_in_where
       expected_ids = %w( D002397 D003064 D003400 D003532 D004284 D004289 D004555 D005412 D006054 D006196 D007059 D007497 D007695 D009990 D010473 D012091 D012487 D012758 D013215 D015027 D020410 D023721 D023761 D023781 D024541 D029961 D037401 D037462 D048251 D049832 D052656 D057096 )
-      expected = expected_ids.map { |id| MESH::Mesh.find(id) }
-      actual = MESH::Mesh.where(entries: /fish/)
+      expected = expected_ids.map { |id| @mesh_tree.find(id) }
+      actual = @mesh_tree.where(entries: /fish/)
       assert_equal expected, actual
     end
 
-    it 'should match on tree numbers in where()' do
+    def test_match_on_tree_numbers_in_where
       expected_ids = %w( D000005 D001415 D010388 D013909 )
-      expected = expected_ids.map { |id| MESH::Mesh.find(id) }
-      actual = MESH::Mesh.where(tree_numbers: /^A01\.923\.[0-9]{3}$/)
+      expected = expected_ids.map { |id| @mesh_tree.find(id) }
+      actual = @mesh_tree.where(tree_numbers: /^A01\.923\.[0-9]{3}$/)
       assert_equal expected, actual
     end
 
-    it 'should match on useful in where' do
-      expected = [MESH::Mesh.find('D012000'), MESH::Mesh.find('D064906'), MESH::Mesh.find('D064966')]
+    def test_match_on_useful_in_where
+      expected = [@mesh_tree.find('D012000'), @mesh_tree.find('D064906'), @mesh_tree.find('D064966')]
       begin
         expected.each { |mh| mh.useful = false }
-        actual = MESH::Mesh.where(useful: false)
+        actual = @mesh_tree.where(useful: false)
         assert_equal expected, actual
       ensure
         expected.each { |mh| mh.useful = true }
       end
     end
 
-    it 'should match on descriptor class in where' do
-      expected = [MESH::Mesh.find('D012000'), MESH::Mesh.find('D064906'), MESH::Mesh.find('D064966')]
+    def test_match_on_descriptor_class_in_where
+      expected = [@mesh_tree.find('D012000'), @mesh_tree.find('D064906'), @mesh_tree.find('D064966')]
       begin
         expected.each { |mh| mh.descriptor_class = :foo }
-        actual = MESH::Mesh.where(descriptor_class: :foo)
+        actual = @mesh_tree.where(descriptor_class: :foo)
         assert_equal expected, actual
       ensure
         expected.each { |mh| mh.descriptor_class = :topical_descriptor }
       end
     end
 
-    it 'should only include useful headings in .each' do
+    def test_only_include_useful_headings_in_each
       begin
-        MESH::Mesh.each do |mh|
+        @mesh_tree.each do |mh|
           mh.useful = false
         end
-        MESH::Mesh.where(unique_id: /^D0000/).each do |mh|
+        @mesh_tree.where(unique_id: /^D0000/).each do |mh|
           mh.useful = true
         end
         count = 0
-        MESH::Mesh.each do |mh|
+        @mesh_tree.each do |mh|
           assert mh.useful
           count += 1
         end
         assert_equal 95, count
       ensure
-        MESH::Mesh.where(useful: false).each do |mh|
+        @mesh_tree.where(useful: false).each do |mh|
           mh.useful = true
         end
       end
     end
 
-    it 'should know its deepest position in the tree' do
+    def test_know_its_deepest_position_in_the_tree
       #single tree numbers
-      assert_equal 1, MESH::Mesh.find('D002319').deepest_position
-      assert_equal 2, MESH::Mesh.find('D001808').deepest_position
-      assert_equal 3, MESH::Mesh.find('D001158').deepest_position
-      assert_equal 4, MESH::Mesh.find('D001981').deepest_position
+      assert_equal 1, @mesh_tree.find('D002319').deepest_position
+      assert_equal 2, @mesh_tree.find('D001808').deepest_position
+      assert_equal 3, @mesh_tree.find('D001158').deepest_position
+      assert_equal 4, @mesh_tree.find('D001981').deepest_position
     end
 
-    it 'should know its shallowest position in the tree' do
+    def test_know_its_shallowest_position_in_the_tree
       #single tree numbers
-      assert_equal 1, MESH::Mesh.find('D002319').shallowest_position
-      assert_equal 2, MESH::Mesh.find('D001808').shallowest_position
-      assert_equal 3, MESH::Mesh.find('D001158').shallowest_position
-      assert_equal 4, MESH::Mesh.find('D001981').shallowest_position
+      assert_equal 1, @mesh_tree.find('D002319').shallowest_position
+      assert_equal 2, @mesh_tree.find('D001808').shallowest_position
+      assert_equal 3, @mesh_tree.find('D001158').shallowest_position
+      assert_equal 4, @mesh_tree.find('D001981').shallowest_position
     end
 
-    it 'should know if one heading is the descendant of another' do
-      parent = MESH::Mesh.find('D002319')
-      child = MESH::Mesh.find('D001808')
-      grandchild = MESH::Mesh.find('D001158')
-      great_grandchild = MESH::Mesh.find('D001981')
-      unrelated = MESH::Mesh.find('D008091')
+    def test_know_if_one_heading_is_the_descendant_of_another
+      parent = @mesh_tree.find('D002319')
+      child = @mesh_tree.find('D001808')
+      grandchild = @mesh_tree.find('D001158')
+      great_grandchild = @mesh_tree.find('D001981')
+      unrelated = @mesh_tree.find('D008091')
 
       refute parent.has_descendant(parent), 'should not consider itself a desecendant'
       assert parent.has_descendant(child), "should consider child #{child.inspect} a descendant of #{parent.inspect} in #{parent.children}"
@@ -409,12 +410,12 @@ module MESH
       refute parent.has_descendant(unrelated), 'should not consider an unrelated heading a descendant'
     end
 
-    it 'should know if one heading is the ancestor of another' do
-      child = MESH::Mesh.find('D001981')
-      parent = MESH::Mesh.find('D001158')
-      grandparent = MESH::Mesh.find('D001808')
-      great_grandparent = MESH::Mesh.find('D002319')
-      unrelated = MESH::Mesh.find('D008091')
+    def test_know_if_one_heading_is_the_ancestor_of_another
+      child = @mesh_tree.find('D001981')
+      parent = @mesh_tree.find('D001158')
+      grandparent = @mesh_tree.find('D001808')
+      great_grandparent = @mesh_tree.find('D002319')
+      unrelated = @mesh_tree.find('D008091')
 
       refute child.has_ancestor(child), 'should not consider itself an ancestor'
       assert child.has_ancestor(parent), "should consider parent #{parent.inspect} an ancestor of #{child.inspect} in #{child.parents}"
@@ -423,13 +424,13 @@ module MESH
       refute child.has_ancestor(unrelated), 'should not consider an unrelated heading an ancestor'
     end
 
-    it 'should know if headings are siblings at the same level below a common parent' do
-      parent = MESH::Mesh.find_by_tree_number('C19.053.500')
-      child1 = MESH::Mesh.find_by_tree_number('C19.053.500.263')
-      child2 = MESH::Mesh.find_by_tree_number('C19.053.500.270')
-      child3 = MESH::Mesh.find_by_tree_number('C19.053.500.480')
-      child4 = MESH::Mesh.find_by_tree_number('C19.053.500.740')
-      unrelated = MESH::Mesh.find('D008091')
+    def test_know_if_headings_are_siblings_at_the_same_level_below_a_common_parent
+      parent = @mesh_tree.find_by_tree_number('C19.053.500')
+      child1 = @mesh_tree.find_by_tree_number('C19.053.500.263')
+      child2 = @mesh_tree.find_by_tree_number('C19.053.500.270')
+      child3 = @mesh_tree.find_by_tree_number('C19.053.500.480')
+      child4 = @mesh_tree.find_by_tree_number('C19.053.500.740')
+      unrelated = @mesh_tree.find('D008091')
       children = [child1, child2, child3, child4]
 
       children.each { |c| refute parent.sibling?(c) }
@@ -442,15 +443,17 @@ module MESH
       children.each { |c| refute c.sibling?(unrelated) }
     end
 
-    it 'should override inspect to prevent issues in test diagnostics' do
-      mh = MESH::Mesh.find('D001471')
+    def test_override_inspect_to_prevent_issues_in_test_diagnostics
+      mh = @mesh_tree.find('D001471')
       expected = "#{mh.unique_id}, #{mh.original_heading}, [#{mh.tree_numbers.join(',')}]"
       assert_equal expected, mh.inspect
     end
 
-    before do
-
-      @example_text = 'Leukaemia in Downs Syndrome
+    def setup
+      @@mesh_tree ||= MESH::Tree.new
+      @@mesh_tree.load_translation(:en_gb)
+      @mesh_tree = @@mesh_tree
+      @example_text ||= 'Leukaemia in Downs Syndrome
 Overview
 Downs Syndrome Leukaemia The link between Downs Syndrome and Leukaemia
 Epidemiology
@@ -619,9 +622,6 @@ why are GATA1 mutations so relatively common in children with DS  It has been po
 thirdly, what is the second-hit  We know that there must be a second genetic event, with GATA1 mutation being the first, but we do not know what this is yet.NB: GATA1 mutation is the first mutation for DS-AMKL.AML  failure of treatment usually due to toxicity due to mucositis and infection.  Resistant disease and relapse are rare.
 ALL  there is no increased sensitivity to treatment, but there is increased risk of toxicity.  Cannot reduce the dose because of the high risk of relapse and so the emphasis is now on improving supportive care.
 '
-
     end
-
-
   end
 end