osm 1.2.15.dev.1 → 1.2.15

data/spec/osm/badge_spec.rb

@@ -18,6 +18,13 @@ describe "Badge" do
         :levels => [1, 2, 3],
         :requirement_notes => 'notes',
         :requirements => [],
+        :modules => [],
+        :min_modules_required => 5,
+        :min_requirements_required => 6,
+        :add_columns_to_module => 7,
+        :level_requirement => 8,
+        :requires_modules => [['A'], ['B', 'C']],
+        :show_level_letters => true,
       }
     end
 
@@ -34,6 +41,13 @@ describe "Badge" do
       badge.levels.should == [1, 2, 3]
       badge.requirement_notes.should == 'notes'
       badge.requirements.should == []
+      badge.modules.should == []
+      badge.min_modules_required.should == 5
+      badge.min_requirements_required.should == 6
+      badge.add_columns_to_module.should == 7
+      badge.level_requirement.should == 8
+      badge.requires_modules.should == [['A'], ['B', 'C']]
+      badge.show_level_letters.should == true
       badge.valid?.should be_true
     end
 
@@ -43,53 +57,95 @@ describe "Badge" do
       badge.valid?.should be_true
     end
 
+    it "Valid with nil for level_requirement" do
+      badge = Osm::Badge.new(@badge_options.merge(level_requirement: nil))
+      badge.level_requirement.should be_nil
+      badge.valid?.should be_true
+    end
+    
+    it "Valid with nil for add_columns_to_module" do
+      badge = Osm::Badge.new(@badge_options.merge(add_columns_to_module: nil))
+      badge.add_columns_to_module.should be_nil
+      badge.valid?.should be_true
+    end
+
   end
 
   it "Create Requirement" do
+    m = Osm::Badge::RequirementModule.new
     requirement = Osm::Badge::Requirement.new(
       :name => 'name',
       :description => 'description',
-      :module_letter => 'a',
-      :field => 1,
+      :mod => m,
+      :id => 1,
       :editable => true,
       :badge => Osm::Badge.new(:identifier => 'key'),
     )
 
     requirement.name.should == 'name'
     requirement.description.should == 'description'
-    requirement.module_letter.should == 'a'
-    requirement.field.should == 1
+    requirement.mod.should == m
+    requirement.id.should == 1
     requirement.editable.should be_true
     requirement.badge.identifier.should == 'key'
     requirement.valid?.should be_true
   end
 
+  it "Create RequirementModule" do
+    b = Osm::Badge.new
+    m = Osm::Badge::RequirementModule.new(
+      badge: b,
+      id: 567,
+      letter: 'a',
+      min_required: 1,
+      custom_columns: 2,
+      completed_into_column: 3,
+      numeric_into_column: 4,
+      add_column_id_to_numeric: 5,
+    )
+
+    m.badge.should == b
+    m.id.should == 567
+    m.letter.should == 'a'
+    m.min_required.should == 1
+    m.custom_columns.should == 2
+    m.completed_into_column.should == 3
+    m.numeric_into_column.should == 4
+    m.add_column_id_to_numeric.should == 5
+    m.valid?.should be_true
+  end
+
+  it "Works out if we add columns to this badge" do
+    Osm::Badge.new(add_columns_to_module: 123).add_columns?.should be_true
+    Osm::Badge.new(add_columns_to_module: nil).add_columns?.should be_false
+  end
+
   it "Produces a map of module letter <-> module id" do
-    badge = Osm::Badge.new(completion_criteria:{ modules: [
-      {module_id: 2, module_letter: 'c'},
-      {module_id: 10, module_letter: 'b'},
-      {module_id: 1, module_letter: 'a'}
-    ]})
+    badge = Osm::Badge.new(modules: [
+      Osm::Badge::RequirementModule.new(id: 2, letter: 'c'),
+      Osm::Badge::RequirementModule.new(id: 10, letter: 'b'),
+      Osm::Badge::RequirementModule.new(id: 1, letter: 'a'),
+    ])
 
     badge.module_map.should == {1=>'a', 10=>'b', 2=>'c', 'a'=>1, 'b'=>10, 'c'=>2}
   end
 
   it "Gets the number of requirements needed per module" do
-    badge = Osm::Badge.new(completion_criteria:{ modules: [
-      {module_id: 2, module_letter: 'c', min_required: 5},
-      {module_id: 10, module_letter: 'b', min_required: 4},
-      {module_id: 1, module_letter: 'a', min_required: 3}
-    ]})
+    badge = Osm::Badge.new(modules: [
+      Osm::Badge::RequirementModule.new(id: 2, letter: 'c', min_required: 5),
+      Osm::Badge::RequirementModule.new(id: 10, letter: 'b', min_required: 4),
+      Osm::Badge::RequirementModule.new(id: 1, letter: 'a', min_required: 3),
+    ])
 
     badge.needed_per_module.should == {'a'=>3, 'b'=>4, 'c'=>5, 2=>5, 10=>4, 1=>3}
   end
 
   it "Produces a list of modules" do
-    badge = Osm::Badge.new(completion_criteria:{ modules: [
-      {module_id: 2, module_letter: 'c'},
-      {module_id: 10, module_letter: 'b'},
-      {module_id: 1, module_letter: 'a'}
-    ]})
+    badge = Osm::Badge.new(modules: [
+      Osm::Badge::RequirementModule.new(id: 2, letter: 'c'),
+      Osm::Badge::RequirementModule.new(id: 10, letter: 'b'),
+      Osm::Badge::RequirementModule.new(id: 1, letter: 'a'),
+    ])
 
     badge.module_letters.should == ['a', 'b', 'c']
     badge.module_ids.should == [1, 2, 10]
@@ -131,14 +187,23 @@ describe "Badge" do
     badges.sort.should == [b1, b2, b3, b4]
   end
 
-  it "Compare badge requirements by badge then field" do
-    b1 = Osm::Badge::Requirement.new(:badge => Osm::Badge.new(:name => 'A'), :field => 'a')
-    b2 = Osm::Badge::Requirement.new(:badge => Osm::Badge.new(:name => 'B'), :field => 'a')
-    b3 = Osm::Badge::Requirement.new(:badge => Osm::Badge.new(:name => 'B'), :field => 'b')
+  it "Compare badge requirements by badge then id" do
+    b1 = Osm::Badge::Requirement.new(:badge => Osm::Badge.new(:name => 'A'), :id => 1)
+    b2 = Osm::Badge::Requirement.new(:badge => Osm::Badge.new(:name => 'B'), :id => 1)
+    b3 = Osm::Badge::Requirement.new(:badge => Osm::Badge.new(:name => 'B'), :id => 2)
     badges = [b3, b1, b2]
     badges.sort.should == [b1, b2, b3]
   end
 
+  it "Compare badge requirement modules by badge then letter then id" do
+    b1 = Osm::Badge::RequirementModule.new(:badge => Osm::Badge.new(:name => 'A'), :letter => 'a', :id => 1)
+    b2 = Osm::Badge::RequirementModule.new(:badge => Osm::Badge.new(:name => 'B'), :letter => 'a', :id => 1)
+    b3 = Osm::Badge::RequirementModule.new(:badge => Osm::Badge.new(:name => 'B'), :letter => 'b', :id => 1)
+    b4 = Osm::Badge::RequirementModule.new(:badge => Osm::Badge.new(:name => 'B'), :letter => 'b', :id => 2)
+    badges = [b3, b4, b1, b2]
+    badges.sort.should == [b1, b2, b3, b4]
+  end
+
   it "Compare badge data by badge, section_id then member_id" do
     b1 = Osm::Badge::Data.new(:badge => Osm::Badge.new(:name => 'A'), :section_id => 1, :member_id => 1)
     b2 = Osm::Badge::Data.new(:badge => Osm::Badge.new(:name => 'B'), :section_id => 1, :member_id => 1)
@@ -165,15 +230,15 @@ describe "Badge" do
     data = Osm::Badge::Data.new(
       :badge => Osm::Badge.new(
         :requirements => [
-          Osm::Badge::Requirement.new(field: 1),
-          Osm::Badge::Requirement.new(field: 2),
-          Osm::Badge::Requirement.new(field: 3),
-          Osm::Badge::Requirement.new(field: 4),
-          Osm::Badge::Requirement.new(field: 5),
-          Osm::Badge::Requirement.new(field: 6),
-          Osm::Badge::Requirement.new(field: 7),
-          Osm::Badge::Requirement.new(field: 8),
-          Osm::Badge::Requirement.new(field: 9),
+          Osm::Badge::Requirement.new(id: 1),
+          Osm::Badge::Requirement.new(id: 2),
+          Osm::Badge::Requirement.new(id: 3),
+          Osm::Badge::Requirement.new(id: 4),
+          Osm::Badge::Requirement.new(id: 5),
+          Osm::Badge::Requirement.new(id: 6),
+          Osm::Badge::Requirement.new(id: 7),
+          Osm::Badge::Requirement.new(id: 8),
+          Osm::Badge::Requirement.new(id: 9),
         ]
       ),
       :requirements => {
@@ -195,19 +260,18 @@ describe "Badge" do
     badge = Osm::Badge.new(
       :needed_from_section => {'a' => 1, 'b' => 2},
       :requirements => [
-        Osm::Badge::Requirement.new(:module_letter=> 'a', :field => '1'),
-        Osm::Badge::Requirement.new(:module_letter=> 'a', :field => '2'),
-        Osm::Badge::Requirement.new(:module_letter=> 'b', :field => '3'),
-        Osm::Badge::Requirement.new(:module_letter=> 'b', :field => '4'),
-        Osm::Badge::Requirement.new(:module_letter=> 'c', :field => '5'),
-        Osm::Badge::Requirement.new(:module_letter=> 'c', :field => '6'),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'a', :id => 100), :id => 1),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'a', :id => 100), :id => 2),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'b', :id => 200), :id => 3),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'b', :id => 200), :id => 4),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'c', :id => 300), :id => 5),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'c', :id => 300), :id => 6),
       ],
-      :completion_criteria => {
-        :modules => [
-        { module_letter: 'a', module_id: 100 },
-        { module_letter: 'b', module_id: 200 },
-        { module_letter: 'c', module_id: 300 }
-      ]}
+      :modules => [
+        Osm::Badge::RequirementModule.new(letter: 'a', id: 100),
+        Osm::Badge::RequirementModule.new(letter: 'b', id: 200),
+        Osm::Badge::RequirementModule.new(letter: 'c', id: 300),
+      ]
     )
     data = Osm::Badge::Data.new(
       :badge => badge,
@@ -219,18 +283,17 @@ describe "Badge" do
   it "Get modules met for a member" do
     badge = Osm::Badge.new(
       :requirements => [
-        Osm::Badge::Requirement.new(:module_letter=> 'a', :field => '1'),
-        Osm::Badge::Requirement.new(:module_letter=> 'a', :field => '2'),
-        Osm::Badge::Requirement.new(:module_letter=> 'b', :field => '3'),
-        Osm::Badge::Requirement.new(:module_letter=> 'b', :field => '4'),
-        Osm::Badge::Requirement.new(:module_letter=> 'c', :field => '5'),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'a', :id => 1000), :id => 1),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'a', :id => 1000), :id => 2),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'b', :id => 2000), :id => 3),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'b', :id => 2000), :id => 4),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter=> 'c', :id => 3000), :id => 5),
       ],
-      :completion_criteria => {
-        :modules => [
-        { module_letter: 'a', module_id: 1000, min_required: 1 },
-        { module_letter: 'b', module_id: 2000, min_required: 2 },
-        { module_letter: 'c', module_id: 3000, min_required: 1 }
-      ]}
+      :modules => [
+        Osm::Badge::RequirementModule.new(letter: 'a', id: 1000, min_required: 1 ),
+        Osm::Badge::RequirementModule.new(letter: 'b', id: 2000, min_required: 2 ),
+        Osm::Badge::RequirementModule.new(letter: 'c', id: 3000, min_required: 1 )
+      ]
     )
     data = Osm::Badge::Data.new(
       :badge => badge,
@@ -255,27 +318,25 @@ describe "Badge" do
     end
 
     it "Non staged" do
-      completion_criteria = {
+      badge = Osm::ActivityBadge.new(
         :min_modules_required => 0,
-        :min_requirements_completed => 0,
+        :min_requirements_required => 0,
         :modules => [
-          {module_id: 1, module_letter: 'a', min_required: 2},
-          {module_id: 2, module_letter: 'b', min_required: 1},
-          {module_id: 3, module_letter: 'c', min_required: 1},
+          Osm::Badge::RequirementModule.new(id: 1, letter: 'a', min_required: 2),
+          Osm::Badge::RequirementModule.new(id: 2, letter: 'b', min_required: 1),
+          Osm::Badge::RequirementModule.new(id: 3, letter: 'c', min_required: 1),
         ],
         :badges_required => [],
-        :fields_required => [],
-      }
-      badge = Osm::ActivityBadge.new(completion_criteria: completion_criteria)
-      badge.requirements = [
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'a', field: 10),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'a', field: 11),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'b', field: 20),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'b', field: 21),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'c', field: 30),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'c', field: 31),
-      ]
-
+        :other_requirements_required => [],
+        :requirements => [
+          Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'a', id: 1), id: 10),
+          Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'a', id: 1), id: 11),
+          Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'b', id: 2), id: 20),
+          Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'b', id: 2), id: 21),
+          Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'c', id: 3), id: 30),
+          Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'c', id: 3), id: 31),
+        ],
+      )
 
       data = Osm::Badge::Data.new(:due => 1, :awarded => 1, :badge => badge)
       data.earnt?.should be_false
@@ -286,9 +347,7 @@ describe "Badge" do
 
       # Number of modules required
       this_badge = badge.clone
-      this_badge.completion_criteria = completion_criteria.merge({
-        :min_modules_required => 2
-      })
+      this_badge.min_modules_required = 2
 
       data = Osm::Badge::Data.new(:requirements => {10=>'y', 11=>'y', 20=>'y'}, :due => 0, :awarded => 0, :badge => this_badge)
       data.earnt?.should be_true
@@ -299,9 +358,8 @@ describe "Badge" do
 
       # Number of requirements needed
       this_badge = badge.clone
-      this_badge.completion_criteria = completion_criteria.merge({
-        :min_requirements_completed => 2
-      })
+      this_badge.min_modules_required = 0
+      this_badge.min_requirements_required = 2
 
       data = Osm::Badge::Data.new(:requirements => {10=>'y', 11=>'y', 20=>'y'}, :due => 0, :awarded => 0, :badge => this_badge)
       data.earnt?.should be_true
@@ -315,9 +373,8 @@ describe "Badge" do
 
       # Module combinations
       this_badge = badge.clone
-      this_badge.completion_criteria = completion_criteria.merge({
-        :requires => [['a'], ['b', 'c']]
-      })
+      this_badge.requires_modules = [['a'], ['b', 'c']]
+
       data = Osm::Badge::Data.new(:requirements => {10=>'x', 11=>'x', 20=>'x', 30=>'x'}, :due => 0, :awarded => 0, :badge => this_badge)
       data.earnt?.should be_false
 
@@ -329,6 +386,32 @@ describe "Badge" do
 
       data = Osm::Badge::Data.new(:requirements => {10=>'y', 11=>'y', 20=>'x', 30=>'y'}, :due => 0, :awarded => 0, :badge => this_badge)
       data.earnt?.should be_true
+
+      # Requirements from another badge
+      this_badge = badge.clone
+      this_badge.min_modules_required = 0
+      this_badge.min_requirements_required = 1
+      this_badge.requires_modules = nil
+      # Simply met
+      this_badge.other_requirements_required = [{id: 100, min: 0}]
+      data = Osm::Badge::Data.new(:requirements => {10=>'y'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_true # Assume met if not in requirements Hash
+      data = Osm::Badge::Data.new(:requirements => {10=>'y', 100=>'x'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_false
+      data = Osm::Badge::Data.new(:requirements => {10=>'y', 100=>'y'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_true
+      # Minimum value
+      this_badge.other_requirements_required = [{id: 100, min: 2}]
+      data = Osm::Badge::Data.new(:requirements => {10=>'y'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_true # Assume met if not in requirements Hash
+      data = Osm::Badge::Data.new(:requirements => {10=>'y', 100=>'x'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_false
+      data = Osm::Badge::Data.new(:requirements => {10=>'y', 100=>'1'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_false
+      data = Osm::Badge::Data.new(:requirements => {10=>'y', 100=>'2'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_true
+      data = Osm::Badge::Data.new(:requirements => {10=>'y', 100=>'3'}, :due => 0, :awarded => 0, :badge => this_badge)
+      data.earnt?.should be_true
     end
   end
 
@@ -337,24 +420,22 @@ describe "Badge" do
     it "Staged (activity)" do
       badge = Osm::StagedBadge.new(
         :levels => [0, 1, 2, 3],
-        :completion_criteria => {
-          :min_modules_required => 0,
-          :min_requirements_completed => 0,
-          :modules => [
-            {module_id: 1, module_letter: 'a', min_required: 1},
-            {module_id: 2, module_letter: 'b', min_required: 1},
-            {module_id: 3, module_letter: 'c', min_required: 1},
-          ],
-          :show_letters => true,
-        }
+        :min_modules_required => 0,
+        :min_requirements_completed => 0,
+        :modules => [
+          Osm::Badge::RequirementModule.new(id: 1, letter: 'a', min_required: 1),
+          Osm::Badge::RequirementModule.new(id: 2, letter: 'b', min_required: 1),
+          Osm::Badge::RequirementModule.new(id: 3, letter: 'c', min_required: 1),
+        ],
+        :show_level_letters => true,
       )
       badge.requirements = [
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'a', field: 10),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'a', field: 11),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'b', field: 20),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'b', field: 21),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'c', field: 30),
-        Osm::Badge::Requirement.new(badge: badge, module_letter: 'c', field: 31),
+        Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'a', id: 1), id: 10),
+        Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'a', id: 1), id: 11),
+        Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'b', id: 2), id: 20),
+        Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'b', id: 2), id: 21),
+        Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'c', id: 3), id: 30),
+        Osm::Badge::Requirement.new(badge: badge, mod: Osm::Badge::RequirementModule.new(letter: 'c', id: 3), id: 31),
       ]
 
       requirements = {10=>'',11=>'',20=>'',21=>'',30=>'',31=>''}
@@ -381,7 +462,8 @@ describe "Badge" do
     it "Staged (count)" do
       badge = Osm::StagedBadge.new(
         :levels => [0,1,2,3,4,5,10,15,20],
-        :completion_criteria => {:show_letters => false, :levels_column_id => 3000},
+        :show_level_letters => false,
+        :level_requirement => 3000,
         :requirements => []
       )
 
@@ -412,11 +494,11 @@ describe "Badge" do
     Osm::Badge::Data.new(
       :badge => Osm::StagedBadge.new(
         :levels => [0,1,2],
-        :completion_criteria => {:show_letters => true},
+        :show_level_letters => true,
         :requirements => [
-          Osm::Badge::Requirement.new(:module_letter => 'a', :field => 1000),
-          Osm::Badge::Requirement.new(:module_letter => 'b', :field => 2000),
-          Osm::Badge::Requirement.new(:module_letter => 'b', :field => 2001),
+          Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter => 'a'), :id => 1000),
+          Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter => 'b'), :id => 2000),
+          Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter => 'b'), :id => 2001),
         ]
       ),
       :requirements => {1000 => 'Yes', 2000 => 'Yes', 2001 => ''},
@@ -425,13 +507,13 @@ describe "Badge" do
 
     # Staged Count Badge
     Osm::Badge::Data.new(
-      :badge => Osm::StagedBadge.new(:levels => [0,1,2,3,4,5,10,15,20], :completion_criteria => {:show_letters => false, :levels_column_id => 1000}),
+      :badge => Osm::StagedBadge.new(:levels => [0,1,2,3,4,5,10,15,20], :show_level_letters => false, :level_requirement => 1000),
       :requirements => {1000 => 5, 2000 => '5', 3000 => ''},
       :due => 5,
       :awarded => 4,
     ).started?.should be_false # Finished lvl 5 & not started lvl 10
     Osm::Badge::Data.new(
-      :badge => Osm::StagedBadge.new(:levels => [0,1,2,3,4,5,10,15,20], :completion_criteria => {:show_letters => false, :levels_column_id => 1000}),
+      :badge => Osm::StagedBadge.new(:levels => [0,1,2,3,4,5,10,15,20], :show_level_letters => false, :level_requirement => 1000),
       :requirements => {1000 => 6, 2000 => '6', 3000 => ''},
       :due => 5,
       :awarded => 3,
@@ -449,11 +531,11 @@ describe "Badge" do
     # Staged Activity
     staged_activity = Osm::StagedBadge.new(
       :levels => [0,1,2],
-      :completion_criteria => {:show_letters => true},
+      :show_level_letters => true,
       :requirements => [
-        Osm::Badge::Requirement.new(:module_letter => 'a', :field => 100),
-        Osm::Badge::Requirement.new(:module_letter => 'b', :field => 200),
-        Osm::Badge::Requirement.new(:module_letter => 'b', :field => 201),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter => 'a'), :id => 100),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter => 'b'), :id => 200),
+        Osm::Badge::Requirement.new(mod: Osm::Badge::RequirementModule.new(:letter => 'b'), :id => 201),
       ]
     )
 
@@ -477,7 +559,8 @@ describe "Badge" do
     # Staged count
     staged_count = Osm::StagedBadge.new(
       :levels => [0,1,2,3,4,5,10,15,20],
-      :completion_criteria => {:show_letters => false, :levels_column_id => 3000},
+      :show_level_letters => false,
+      :level_requirement => 3000,
       :requirements => []
     )
 
@@ -507,7 +590,7 @@ describe "Badge" do
               'badge_identifier' => '123_0',
               'badge_order' => '4',
               'badge_version' => '0',
-              'config' => '{"numModulesRequired":1}',
+              'config' => '{"numModulesRequired":1,"shownumbers":true}',
               'description' => 'b_req_notes',
               'group_name' => '',
               'lastupdated' => '2014-09-14 02:32:05',
@@ -581,38 +664,35 @@ describe "Badge" do
           badge.user_id.should == 0
           badge.sharing.should == :default_locked
           badge.requirements.size.should == 1
+          badge.min_modules_required.should == 1
+          badge.min_requirements_required.should == 0
+          badge.add_columns_to_module.should == nil
+          badge.level_requirement.should == nil
+          badge.requires_modules.should == nil
+          badge.other_requirements_required.should == []
+          badge.badges_required.should == []
+          badge.show_level_letters.should == true
           badge.valid?.should be_true
+          badge.modules.size.should == 1
+          m = badge.modules[0]
+          m.badge.id.should == 123
+          m.badge.version.should == 0
+          m.id.should == 234
+          m.letter.should == 'a'
+          m.min_required.should == 0
+          m.custom_columns.should == 0
+          m.completed_into_column.should == nil
+          m.numeric_into_column.should == nil
+          m.add_column_id_to_numeric.should == nil
+          m.valid?.should be_true
           requirement = badge.requirements[0]
           requirement.name.should == 'r_name'
           requirement.description.should == 'r_description'
-          requirement.field.should == 2345
-          requirement.module_letter.should == 'a'
+          requirement.id.should == 2345
+          requirement.mod.should == m
           requirement.editable.should be_true
           requirement.badge.should == badge
           requirement.valid?.should be_true
-          badge.completion_criteria.should == {
-            :min_modules_required => 1,
-            :fields_required => [],
-            :badges_required => [],
-            :min_requirements_completed => 0,
-            :requires => nil,
-            :add_columns_to_module => nil,
-            :levels_column => nil,
-            :show_letters => false,
-            :modules => [
-              {
-                :badge_id => 123,
-                :badge_version => 0,
-                :module_id => 234,
-                :module_letter => 'a',
-                :min_required => 0,
-                :custom_columns => 0,
-                :completed_into_column => nil,
-                :numeric_into_column => nil,
-                :add_column_id_to_numeric => nil,
-              }
-            ]
-          }
         end
       end
 
@@ -676,8 +756,8 @@ describe "Badge" do
             :id => 123,
             :version => 0,
             :requirements => [
-              Osm::Badge::Requirement.new(:field => 2345, :editable => true),
-              Osm::Badge::Requirement.new(:field => 6789, :editable => true),
+              Osm::Badge::Requirement.new(:id => 2345, :editable => true),
+              Osm::Badge::Requirement.new(:id => 6789, :editable => true),
             ]),
           :due => 0,
         )