update specs/features using deprecated syntax

Author: miquella

features/step_definitions/scorm_cloud_steps.rb

@@ -2,7 +2,7 @@
 ## Generic
 ##
 Then /^I will get a valid url$/ do
-  @last_url.should match(/http\:\/\/.+/)
+  expect(@last_url).to match(/http\:\/\/.+/)
 end
 
 
@@ -23,11 +23,11 @@
 end
 
 Then /^the response should be "([^"]*)"$/ do |arg1| #"
-  @last_response.should eq(arg1)
+  expect(@last_response).to eq(arg1)
 end
 
 Then /^the resonse should be the current time$/ do
-  @last_response.should match(/\d+/)
+  expect(@last_response).to match(/\d+/)
 end
 
 ##
@@ -36,21 +36,21 @@
 
 When /^I upload a package$/ do
   token = @c.upload.get_upload_token
-  token.should_not be_nil
+  expect(token).to_not be_nil
   path = File.join(File.dirname(__FILE__), '..', '..', 'spec', 'small_scorm_package.zip')
   @last_upload_path = @c.upload.upload_file(token, path)
   @last_uploaded_dir, @last_uploaded_file = @last_upload_path.split('/')
-  @last_uploaded_file.should include('.zip')
+  expect(@last_uploaded_file).to include('.zip')
 end
 
 Then /^the package files should be available$/ do
   list = @c.upload.list_files.map { |f| f[:file] }
-  list.should include(@last_uploaded_file)
+  expect(list).to include(@last_uploaded_file)
 end
 
 Then /^the package files should not be available$/ do
   list = @c.upload.list_files.map { |f| f[:file] }
-  list.should_not include(@last_uploaded_file)
+  expect(list).to_not include(@last_uploaded_file)
 end
 
 When /^I delete the package$/ do
@@ -68,7 +68,7 @@
 end
 
 Then /^I should get an error$/ do
-  @last_error.should_not be_nil
+  expect(@last_error).to_not be_nil
 end
 
 
@@ -78,70 +78,70 @@
 ##
 
 When /^I import a course$/ do
-  @last_uploaded_file.should_not be_nil
+  expect(@last_uploaded_file).to_not be_nil
   @last_course_id = "small_scorm_course_#{rand(1000)}"
   hash = @c.course.import_course(@last_course_id, @last_uploaded_path)
-  hash.should_not be_nil
-  hash[:title].should_not be_nil
+  expect(hash).to_not be_nil
+  expect(hash[:title]).to_not be_nil
 end
 
 Given /^a registered course$/ do
-  When "I import a course"
+  step "I import a course"
 end
 
 Then /^the course should be in the course list$/ do
-  @c.course.get_course_list.find { |c| c.id == @last_course_id}.should_not be_nil
+  expect(@c.course.get_course_list.find { |c| c.id == @last_course_id}).to_not be_nil
 end
 
 Then /^there should be (\d+) courses? in the list$/ do |count|
-  @c.course.get_course_list.size.should eq(count.to_i)
+  expect(@c.course.get_course_list.size).to eq(count.to_i)
 end
 
 When /^I delete the course$/ do
-  @c.course.delete_course(@last_course_id).should eq(true)
+  expect(@c.course.delete_course(@last_course_id)).to eq(true)
 end
 
 Then /^the course should not be in the course list$/ do
-  @c.course.get_course_list.find { |c| c.id == @last_course_id}.should be_nil
+  expect(@c.course.get_course_list.find { |c| c.id == @last_course_id}).to be_nil
 end
 
 Then /^I can get a preview URL for the course$/ do
-  @c.course.preview(@last_course_id, "http://www.example.com").should match(/http:\/\/.+/)
+  expect(@c.course.preview(@last_course_id, "http://www.example.com")).to match(/http:\/\/.+/)
 end
 
 Then /^the course will have a properties url$/ do
-  @c.course.properties(@last_course_id).should match(/http:\/\/.+/)
+  expect(@c.course.properties(@last_course_id)).to match(/http:\/\/.+/)
 end
 
 Then /^the course should exist$/ do
-  @c.course.exists(@last_course_id).should be_true
+  expect(@c.course.exists(@last_course_id)).to be(true)
 end
 
 Then /^I can get the manifest for the course$/ do
   xml = @c.course.get_manifest(@last_course_id)
   doc = REXML::Document.new(xml)
-  doc.elements["//manifest"].should_not be_nil
+  expect(doc.elements["//manifest"]).to_not be_nil
 end
 
 Then /^I can get the attributes for the course$/ do
   h = @c.course.get_attributes(@last_course_id)
-  h.should be_kind_of(Hash)
-  h[:showProgressBar].should eq("false")
-  h[:showCourseStructure].should eq("false")
+  expect(h).to be_kind_of(Hash)
+  expect(h[:showProgressBar]).to eq("false")
+  expect(h[:showCourseStructure]).to eq("false")
 end
 
 When /^I update course attributes$/ do
   updated = @c.course.update_attributes(@last_course_id, 
     {:desiredHeight => "700", :commCommitFrequency => "59999" })
-  updated[:desiredHeight].should eq("700")
-  updated[:commCommitFrequency].should eq("59999")
+  expect(updated[:desiredHeight]).to eq("700")
+  expect(updated[:commCommitFrequency]).to eq("59999")
 end
 
 Then /^the course attributes should be updated$/ do
   h = @c.course.get_attributes(@last_course_id)
-  h.should be_kind_of(Hash)
-  h[:desiredHeight].should eq("700")
-  h[:commCommitFrequency].should eq("59999")
+  expect(h).to be_kind_of(Hash)
+  expect(h[:desiredHeight]).to eq("700")
+  expect(h[:commCommitFrequency]).to eq("59999")
 end
 
 
@@ -153,25 +153,25 @@
   @last_reg_id = "small_scorm_course_#{rand(1000)}"
   r = @c.registration.create_registration(@last_course_id, @last_reg_id, 
       "fname", "lname", "lid", :email => "lid@example.com")
-  r.should be_true
+  expect(r).to be(true)
 end
 
 Then /^the learner should be in the registration list$/ do
   list = @c.registration.get_registration_list
-  list.find { |r| r.id == @last_reg_id }.should_not be_nil
+  expect(list.find { |r| r.id == @last_reg_id }).to_not be_nil
 end
 
 Then /^the learner should not be in the registration list$/ do
   list = @c.registration.get_registration_list
-  list.find { |r| r.id == @last_reg_id }.should be_nil
+  expect(list.find { |r| r.id == @last_reg_id }).to be_nil
 end
 
 When /^I delete the registration$/ do
-  @c.registration.delete_registration(@last_reg_id).should be_true
+  expect(@c.registration.delete_registration(@last_reg_id)).to be(true)
 end
 
 When /^I reset the registration$/ do
-  @c.registration.reset_registration(@last_reg_id).should be_true
+  expect(@c.registration.reset_registration(@last_reg_id)).to be(true)
 end
 
 When /^I launch the course$/ do
@@ -180,5 +180,5 @@
 
 Then /^I can get the registration results$/ do
   @reg_results = @c.registration.get_registration_result(@last_reg_id, "full")
-  @reg_results.should include('<rsp stat="ok"><registrationreport')
+  expect(@reg_results).to include('<rsp stat="ok"><registrationreport')
 end

features/support/env.rb

@@ -18,7 +18,6 @@
 ## Cleanup before testing
 ##
 Before do
-
   # Grab a connection
   unless @c
     @c = ScormCloud::ScormCloud.new($scorm_cloud_appid,$scorm_cloud_secret)
@@ -28,10 +27,9 @@
   @c.course.get_course_list.each do |course|
     @c.course.delete_course(course.id)
   end
-  @c.course.get_course_list.count.should eq(0)
+  expect(@c.course.get_course_list.count).to eq(0)
 
   unless @last_uploaded_file
-
     # Cleanup all zip packages
     @c.upload.list_files.each do |file|
       @c.upload.delete_files(file[:file])
@@ -43,29 +41,23 @@
     path = File.join(File.dirname(__FILE__), '..', '..', 'spec', 'small_scorm_package.zip')
     @last_uploaded_path = @c.upload.upload_file(token, path)
     @last_uploaded_dir, @last_uploaded_file = @last_uploaded_path.split('/')
-    @last_uploaded_file.should include('.zip')
+    expect(@last_uploaded_file).to include('.zip')
 
     sleep(5)
-
   end
 
   # was a course created?
-  @c.course.get_course_list.count.should eq(0)
-  @c.upload.list_files.count.should eq(1)
+  expect(@c.course.get_course_list.count).to eq(0)
+  expect(@c.upload.list_files.count).to eq(1)
 
   @last_course_id = nil
   @last_error = nil
   @last_response = nil
-
 end
 
-
 After do
-
   # Cleanup all courses
   @c.course.get_course_list.each do |course|
     @c.course.delete_course(course.id)
   end
-
 end
-

spec/debug_service_spec.rb

@@ -8,15 +8,15 @@
     it { should respond_to(:get_time).with(0).arguments }
 
     it "should ping the server" do
-      subject.ping.should include("pong")
+      expect(subject.ping).to include("pong")
     end
 
     it "should auth_ping the server" do
-      subject.auth_ping.should include("pong")
+      expect(subject.auth_ping).to include("pong")
     end
 
     it "should get the time" do
-      subject.get_time.should match(/\d+/)
+      expect(subject.get_time).to match(/\d+/)
     end
   end
 end