verso 0.0.2 → 0.0.3

data/spec/standard_spec.rb

@@ -1,53 +1,111 @@
 require 'spec_helper'
 
 describe Verso::Standard do
+  use_vcr_cassette :record => :new_episodes
+
   before do
-    @goal = { "title" => "goal title",
-              "description" => "goal description" }
-    @nested_goal = { "title" => "nested goal title",
-                     "description" => "nested goal description" }
-    @section = { "title" => "section title",
-                 "description" => "section description",
-                 "goals" => [@nested_goal], "sections" => [] }
-    @raw_standard =  { :aname => { "title" => "standard title",
-                                   "description" => "standard description",
-                                   "goals" => [@goal],
-                                   "sections" => [@section] } }
-    @standard = Verso::Standard.new(@raw_standard.values.first)
+    @standard = Verso::Standard.new(
+      :code  => "6135",
+      :edition => Verso::EditionList.new.last.year,
+      :name => "english"
+    )
   end
 
-  it "should respond to title" do
-    @standard.title.should eq("standard title")
-  end
+  describe '#description' do
+    it 'responds' do
+      @standard.should respond_to(:description)
+    end
 
-  it "should respond to description" do
-    @standard.description.should eq("standard description")
+    it 'is a string' do
+      @standard.description.should be_a(String)
+    end
   end
 
-  it "should respond to sections" do
-    @standard.sections.first.title.should eq(@section["title"])
+  describe '#goals' do
+    it 'responds' do
+      @standard.should respond_to(:goals)
+    end
+
+    it 'is an Array' do
+      @standard.goals.should be_a(Array)
+    end
+
+    it 'is an Array of OpenStruct objects' do
+      @standard.goals.first.should be_a(OpenStruct)
+    end
+
+    describe 'OpenStruct goal objects' do
+      before do
+        @goal = @standard.goals.first
+      end
+
+      describe '#title' do
+        it 'responds' do
+          @goal.should respond_to(:title)
+        end
+
+        it 'is a string' do
+          @goal.title.should be_a(String)
+        end
+      end
+
+      describe '#description' do
+        it 'responds' do
+          @goal.should respond_to(:description)
+        end
+
+        it 'is a String' do
+          @goal.description.should be_a(String)
+        end
+
+        it 'looks like HTML' do
+          @goal.description.should match(/<\/.+>/)
+        end
+      end
+    end
   end
 
-  it "should respond to goals" do
-    @standard.goals.first.title.should eq("goal title")
+  describe '#name' do
+    it 'responds' do
+      @standard.should respond_to(:name)
+    end
+
+    it 'is a String' do
+      @standard.name.should be_a(String)
+    end
+
+    it 'looks like the title' do
+      @standard.name.should == 'english'
+    end
   end
 
-  it "should respond to nested goals" do
-    @standard.sections.first.goals.first.title.should eq("nested goal title")
+  describe '#sections' do
+    it 'responds' do
+      @standard.should respond_to(:sections)
+    end
+
+    it 'is an Array' do
+      @standard.sections.should be_a(Array)
+    end
+
+    it 'is an Array of Verso::Standard objects' do
+      # english doesn't have subsections, so . . .
+      std = Verso::Standard.new(
+        :code => "8276",
+        :edition => Verso::EditionList.new.last.year,
+        :name => 'fccla_activities--competitive_events'
+      )
+      std.sections.first.should be_a(Verso::Standard)
+    end
   end
 
-  it "should fetch standard as necessary" do
-    course = OpenStruct.new(:code => "6320", :edition => "2011")
-    std = { "name" => "science" }
-    std = Verso::Standard.new(std, course)
-    std.name.should eq("science")
-    std.code.should eq("6320")
-
-    raw_std = { "standard" => { "title" => "Science", "sections" => [],
-                                "goals" => [] } }
-    Net::HTTP.stub(:get).and_return(nil)
-    JSON.stub(:parse).and_return(raw_std)
-    std.title.should eq("Science")
-    std.name.should eq("science")
+  describe '#title' do
+    it 'responds' do
+      @standard.should respond_to(:title)
+    end
+
+    it 'is a String' do
+      @standard.title.should be_a(String)
+    end
   end
 end

data/spec/standards_list_spec.rb

@@ -1,51 +1,145 @@
 require 'spec_helper'
 
 describe Verso::StandardsList do
+  use_vcr_cassette :record => :new_episodes
+
   before do
-    @goal = OpenStruct.new({ "title" => "goal title",
-                             "description" => "goal description" })
-    @nested_goal = OpenStruct.new(
-      { "title" => "nested goal title",
-        "description" => "nested goal description" }
-    )
-    @section = OpenStruct.new(
-      { "title" => "section title", "description" => "section description",
-        "goals" => [@nested_goal], "sections" => [] }
+    @list = Verso::StandardsList.new(
+      :code => "6320",
+      :edition => Verso::EditionList.new.last.year
     )
-    @raw_standard =  { :aname => { "title" => "standard title",
-                                   "description" => "standard description",
-                                   "goals" => [@goal],
-                                   "sections" => [@section] } }
-    sol =  { :science => { "title" => "Science",
-                           "description" => "standard description",
-                           "name" => "science",
-                           "goals" => [@goal],
-                           "sections" => [@section] } }
-    @raw_standard.merge!(sol)
-    @standards_list = Verso::StandardsList.new(@raw_standard)
   end
 
-  it "responds as Enumerable" do
-    @standards_list.last.title.should eq("standard title")
-    @standards_list.first.title.should eq("Science")
+  describe 'array-like behavior' do
+    describe '#[]' do
+      it 'responds' do
+        @list.should respond_to(:[])
+      end
+
+      it 'gets a Verso::Standard object' do
+        @list[2].should be_a(Verso::Standard)
+      end
+    end
+
+    describe '#each' do
+      it 'responds' do
+        @list.should respond_to(:each)
+      end
+
+      it 'yields' do
+        expect { |b| @list.each("foo", &b).to yield_control }
+      end
+
+      it 'yields Verso::Standard objects' do
+        @list.each { |c| c.should be_a(Verso::Standard) }
+      end
+    end
+
+    describe '#empty?' do
+      it 'responds' do
+        @list.should respond_to(:empty?)
+      end
+
+      it 'is not empty' do
+        @list.should_not be_empty
+      end
+    end
+
+    describe '#last' do
+      it 'responds' do
+        @list.should respond_to(:last)
+      end
+
+      it 'is a Verso::Standard object' do
+        @list.last.should be_a(Verso::Standard)
+      end
+    end
+
+    describe '#length' do
+      it 'responds' do
+        @list.should respond_to(:length)
+      end
+
+      it 'is a Fixnum' do
+        @list.length.should be_a(Fixnum)
+      end
+    end
+
+    describe '#first' do
+      it 'responds' do
+        @list.should respond_to(:first)
+      end
+
+      it 'is a Verso::Standard object' do
+        @list.first.should be_a(Verso::Standard)
+      end
+    end
+
+    describe '#count' do
+      it 'responds' do
+        @list.should respond_to(:count)
+      end
+
+      it 'is a Fixnum' do
+        @list.count.should be_a(Fixnum)
+      end
+    end
   end
 
-  it "should respond to sols" do
-    @standards_list.sols.first.title.should eq('Science')
+  describe '#non_sols' do
+    it 'responds' do
+      @list.should respond_to(:non_sols)
+    end
+
+    it 'is an Array' do
+      @list.non_sols.should be_a(Array)
+    end
+
+    it 'is an Array of Verso::Standard Objects' do
+      @list.non_sols.first.should be_a(Verso::Standard)
+    end
+
+    it 'does not include SOLs like English' do
+      @list.non_sols.any? { |s| s.title == 'English'}.should be_false
+    end
   end
 
-  it "should respond to non_sols" do
-    @standards_list.non_sols.first.title.should eq("standard title")
+  describe '#sols' do
+    it 'responds' do
+      @list.should respond_to(:sols)
+    end
+
+    it 'is an Array' do
+      @list.sols.should be_a(Array)
+    end
+
+    it 'is an Array of Verso::Standard Objects' do
+      @list.sols.first.should be_a(Verso::Standard)
+    end
+
+    it 'includes SOLs like English' do
+      @list.sols.any? { |s| s.title == 'English' }.should be_true
+    end
   end
 
-  it "should create a list from a course" do
-    course = double("Course", :code => "6320", :edition => "2011")
-    Net::HTTP.stub(:get).and_return(nil)
-    raw = { "standards" => @raw_standard.values }
-    JSON.stub(:parse).and_return(raw)
-    sl = Verso::StandardsList.new(raw["standards"], course)
-    Verso::StandardsList.should_receive(:new).with(raw["standards"], course).
-      and_return(sl)
-    Verso::StandardsList.from_course(course).last.title.should eq("standard title")
+  describe 'self.from_course' do
+    before do
+      @course = Verso::CourseList.new(:code => "6320").last
+    end
+
+    it 'responds' do
+      Verso::StandardsList.should respond_to(:from_course)
+    end
+
+    it 'returns a Verso::StandardsList' do
+      Verso::StandardsList.from_course(@course).
+        should be_a(Verso::StandardsList)
+    end
+
+    it 'has the correct code and edition' do
+      list = Verso::StandardsList.from_course(@course)
+      list.code.should == @course.code
+      list.edition.should == @course.edition
+    end
   end
 end

data/spec/task_list_spec.rb

@@ -4,69 +4,178 @@ describe Verso::TaskList do
   use_vcr_cassette :record => :new_episodes
 
   before do
-    @tl = Verso::TaskList.new(:code => "6320", :edition => "2011")
+    @tl = Verso::TaskList.new(
+      :code => "6320",
+      :edition => Verso::EditionList.new.last.year)
   end
 
-  it "responds to #first" do
-    @duty_area = double("Verso::DutyArea", :title => "A Verso::Duty Area")
-    Verso::DutyArea.should_receive(:new).and_return(@duty_area)
-    @tl.first.title.should eq("A Verso::Duty Area")
-  end
+  describe '#code' do
+    it 'responds' do
+      @tl.should respond_to(:code)
+    end
 
-  it "responds to #code, #edition" do
-    @tl.code.should eq("6320")
-    @tl.edition.should eq("2011")
+    it 'is a String' do
+      @tl.code.should be_a(String)
+    end
   end
 
-  it "responds to #has_optional_task? when true" do
-    @tl.stub(:duty_areas).and_return(
-      [{"title" => "DA Title",
-        "tasks" => [
-          { "statement" => "one",
-            "sensitive" => false,
-            "essential" => true }
-        ]}]
-    )
-    @tl.has_optional_task?.should eq(false)
+  describe '#edition' do
+    it 'responds' do
+      @tl.should respond_to(:edition)
+    end
+
+    it 'is a String' do
+      @tl.edition.should be_a(String)
+    end
   end
 
-  it "responds to #has_optional_task? when false" do
-    @tl.stub(:duty_areas).and_return(
-      [{"title" => "DA Title",
-        "tasks" => [
-          { "statement" => "one",
-            "sensitive" => false,
-            "essential" => false }
-        ]}]
-    )
-    @tl.has_optional_task?.should eq(true)
+  describe '#has_optional_task?' do
+    it 'responds' do
+      @tl.should respond_to(:has_optional_task?)
+    end
+
+    it 'is Boolean' do
+      @tl.has_optional_task?.to_s.should match(/true|false/)
+    end
+
+    it 'is true if a task is non-essential' do
+      tl = Verso::TaskList.new(
+        :code => "6320",
+        :edition => Verso::EditionList.new.last.year,
+        :duty_areas => [
+          { :title => "",
+            :tasks => [
+              { :statement => '', :id => "12",
+                :sensitive => false, :essential => false }
+            ]
+        }]
+      )
+      tl.has_optional_task?.should be_true
+    end
+
+    it 'is false if all tasks are essential' do
+      tl = Verso::TaskList.new(
+        :code => "6320",
+        :edition => Verso::EditionList.new.last.year,
+        :duty_areas => [
+          { :title => "",
+            :tasks => [
+              { :statement => '', :id => "12",
+                :sensitive => false, :essential => true }
+            ]
+        }]
+      )
+      tl.has_optional_task?.should be_false
+    end
   end
 
-  it "responds to #has_sensitive_task? when true" do
-    @tl.stub(:duty_areas).and_return(
-      [{"title" => "DA Title",
-        "tasks" => [
-          { "statement" => "one",
-            "sensitive" => true }
-          ]}]
-    )
-    @tl.has_sensitive_task?.should eq(true)
+  describe '#has_sensitive_task?' do
+    it 'responds' do
+      @tl.should respond_to(:has_sensitive_task?)
+    end
+
+    it 'is Boolean' do
+      @tl.has_sensitive_task?.to_s.should match(/true|false/)
+    end
+
+    it 'is false if no task is sensitive' do
+      @tl.has_sensitive_task?.should be_false
+    end
+
+    it 'is true if a task is sensitive' do
+      tl = Verso::TaskList.new(
+        :code => "6320",
+        :edition => Verso::EditionList.new.last.year,
+        :duty_areas => [
+          { :title => "",
+            :tasks => [
+              { :statement => '', :id => "12",
+                :sensitive => true, :essential => true }
+            ]
+        }]
+      )
+      tl.has_sensitive_task?.should be_true
+    end
   end
 
-  it "responds to #has_sensitive_task? when false" do
-    @tl.stub(:duty_areas).and_return(
-      [{"title" => "DA Title",
-        "tasks" => [
-          { "statement" => "one",
-            "sensitive" => false }
-          ]}]
-    )
-    @tl.has_sensitive_task?.should eq(false)
+  describe 'array-like behavior' do
+    describe '#[]' do
+      it 'responds' do
+        @tl.should respond_to(:[])
+      end
+
+      it 'gets a Verso::DutyArea object' do
+        @tl[10].should be_a(Verso::DutyArea)
+      end
+    end
+
+    describe '#each' do
+      it 'responds' do
+        @tl.should respond_to(:each)
+      end
+
+      it 'yields' do
+        expect { |b| @tl.each("foo", &b).to yield_control }
+      end
+
+      it 'yields Verso::DutyArea objects' do
+        @tl.each { |c| c.should be_a(Verso::DutyArea) }
+      end
+    end
+
+    describe '#empty?' do
+      it 'responds' do
+        @tl.should respond_to(:empty?)
+      end
+
+      it 'is not empty' do
+        @tl.should_not be_empty
+      end
+    end
+
+    describe '#last' do
+      it 'responds' do
+        @tl.should respond_to(:last)
+      end
+
+      it 'is a Verso::DutyArea object' do
+        @tl.last.should be_a(Verso::DutyArea)
+      end
+    end
+
+    describe '#length' do
+      it 'responds' do
+        @tl.should respond_to(:length)
+      end
+
+      it 'is a Fixnum' do
+        @tl.length.should be_a(Fixnum)
+      end
+    end
+
+    describe '#first' do
+      it 'responds' do
+        @tl.should respond_to(:first)
+      end
+
+      it 'is a Verso::DutyArea object' do
+        @tl.first.should be_a(Verso::DutyArea)
+      end
+    end
+
+    describe '#count' do
+      it 'responds' do
+        @tl.should respond_to(:count)
+      end
+
+      it 'is a Fixnum' do
+        @tl.count.should be_a(Fixnum)
+      end
+    end
   end
 
-  it "should return an empty task list if none is published" do
-    @tl = Verso::TaskList.new(:code => "1234", :edition => "1929")
-    JSON.stub(:parse).and_return({ "errors" => "Not Found" })
-    @tl.duty_areas.should eq([])
+  it "is empty if no task list is published" do
+    tl = Verso::TaskList.new(:code => "1234", :edition => "1929")
+    tl.should be_empty
   end
 end