scorm_engine 0.1.0

data/spec/scorm_engine/api/endpoints/registrations_spec.rb

@@ -0,0 +1,201 @@
+RSpec.describe ScormEngine::Api::Endpoints::Registrations do
+  let(:subject) { scorm_engine_client }
+
+  let(:registration_options) { {
+    course_id: "testing-golf-explained",
+    registration_id: "testing-golf-explained-registration-1",
+    learner: {
+      id: "testing-golf-explained-learner-1",
+      first_name: "Arnold",
+      last_name: "Palmer",
+    }
+  } }
+
+  before do
+    against_real_scorm_engine do
+      ensure_course_exists(client: subject, course_id: registration_options[:course_id])
+      ensure_registration_exists(registration_options.merge(client: subject))
+      ensure_course_exists(client: subject, course_id: registration_options[:course_id] + "-no-registrations")
+    end
+  end
+
+  describe "#get_registrations" do
+    let(:registrations) { subject.get_registrations }
+
+    it "is successful" do
+      expect(registrations.success?).to eq true
+    end
+
+    it "returns an array of registrations" do
+      expect(registrations.result.all? { |r| r.is_a?(ScormEngine::Models::Registration) }).to eq true
+    end
+
+    it "includes results we expect" do
+      reg = registrations.result.detect { |r| r.id == registration_options[:registration_id] }
+      expect(reg).not_to be nil
+    end
+
+    describe "filtering by course_id" do
+      it "includes results" do
+        registrations = subject.get_registrations(course_id: registration_options[:course_id])
+        reg = registrations.result.detect { |r| r.id == registration_options[:registration_id] }
+        expect(reg).not_to be nil
+      end
+
+      it "excludes results" do
+        registrations = subject.get_registrations(course_id: registration_options[:course_id] + "-no-registrations")
+        reg = registrations.result.detect { |r| r.id == registration_options[:registration_id] }
+        expect(reg).to be nil
+      end
+    end
+
+    describe "filtering by learner_id" do
+      it "includes results" do
+        registrations = subject.get_registrations(learner_id: registration_options[:learner][:id])
+        reg = registrations.result.detect { |r| r.id == registration_options[:registration_id] }
+        expect(reg).not_to be nil
+      end
+
+      it "excludes results" do
+        registrations = subject.get_registrations(learner_id: "some-other-learner-id")
+        reg = registrations.result.detect { |r| r.id == registration_options[:registration_id] }
+        expect(reg).to be nil
+      end
+    end
+  end
+
+  describe "#get_registration_instances" do
+    let(:registrations) { subject.get_registration_instances(registration_id: registration_options[:registration_id]) }
+
+    it "is successful" do
+      expect(registrations.success?).to eq true
+    end
+
+    it "returns an array of registrations" do
+      expect(registrations.result.all? { |r| r.is_a?(ScormEngine::Models::Registration) }).to eq true
+    end
+
+    it "includes results we expect" do
+      reg = registrations.result.detect { |r| r.id == registration_options[:registration_id] }
+      expect(reg).not_to be nil
+    end
+  end
+
+  describe "#get_registration_exists" do
+    it "is true when registration exists" do
+      response = subject.get_registration_exists(registration_id: registration_options[:registration_id])
+      aggregate_failures do
+        expect(response.success?).to eq true
+        expect(response.result).to eq true
+      end
+    end
+
+    it "is false when registration does not exist" do
+      response = subject.get_registration_exists(registration_id: "reg-does-not-exist")
+      aggregate_failures do
+        expect(response.result).to eq false
+        expect(response.status).to eq 404
+      end
+    end
+  end
+
+  describe "#get_registration_progress" do
+    it "returns a registration when it exists" do
+      response = subject.get_registration_progress(registration_id: registration_options[:registration_id])
+      aggregate_failures do
+        expect(response.success?).to eq true
+        expect(response.result).to be_a ScormEngine::Models::Registration
+        expect(response.result.id).to eq registration_options[:registration_id]
+      end
+    end
+
+    it "fails when registration does not exist" do
+      response = subject.get_registration_progress(registration_id: "reg-does-not-exist")
+      aggregate_failures do
+        expect(response.success?).to eq false
+        expect(response.status).to eq 404
+        expect(response.result).to be_falsey
+      end
+    end
+
+    context "detail" do
+      it "does not return activity_details by default" do
+        response = subject.get_registration_progress(registration_id: registration_options[:registration_id])
+        expect(response.result.activity_details).to eq nil
+      end
+
+      it "returns activity_details if requested" do
+        response = subject.get_registration_progress(registration_id: registration_options[:registration_id], detail: true)
+        expect(response.result.activity_details).to be_a ScormEngine::Models::RegistrationActivityDetail
+      end
+    end
+  end
+
+  describe "#delete_registration" do
+    it "is successful when registration exists" do
+      response = subject.delete_registration(registration_id: registration_options[:registration_id])
+      aggregate_failures do
+        expect(response.success?).to eq true
+      end
+    end
+
+    it "is failure when registration does not exist" do
+      response = subject.delete_registration(registration_id: "reg-does-not-exist")
+      aggregate_failures do
+        expect(response.success?).to eq false
+        expect(response.status).to eq 404
+      end
+    end
+  end
+
+  describe "#post_registration" do
+    it "is successful" do
+      subject.delete_registration(registration_options)
+      response = subject.post_registration(registration_options)
+      aggregate_failures do
+        expect(response.success?).to eq true
+        expect(response.status).to eq 204
+      end
+    end
+
+    it "fails if course_id is invalid" do
+      response = subject.post_registration(registration_options.merge(course_id: "invalid-bogus"))
+      aggregate_failures do
+        expect(response.success?).to eq false
+        expect(response.status).to eq 400
+        expect(response.message).to match(/External Package ID 'invalid-bogus'/)
+      end
+    end
+
+    it "fails if registration_id already exists" do
+      response = subject.post_registration(registration_options)
+      aggregate_failures do
+        expect(response.success?).to eq false
+        expect(response.status).to eq 400
+        expect(response.message).to match(/This RegistrationId is already in use/)
+      end
+    end
+  end
+
+  describe "#get_registration_launch_link" do
+    let(:response) { subject.get_registration_launch_link(registration_id: registration_options[:registration_id], redirect_on_exit_url: "https://example.com") }
+
+    it "is successful" do
+      expect(response.success?).to eq true
+    end
+
+    describe "results" do
+      it "returns a URL string" do
+        url = response.result
+        expect(url).to match(%r{/defaultui/launch.jsp\?.*registration=#{registration_options[:registration_id]}.*RedirectOnExitUrl=https%3A%2F%2Fexample.com})
+      end
+    end
+
+    it "fails when id is invalid" do
+      response = subject.get_registration_launch_link(registration_id: "nonexistent-registration")
+      expect(response.success?).to eq false
+      expect(response.status).to eq 404
+      expect(response.message).to match(/External Registration ID 'nonexistent-registration'/)
+    end
+  end
+end

data/spec/scorm_engine/configuration_spec.rb

@@ -0,0 +1,29 @@
+RSpec.describe ScormEngine::Configuration do
+  before do
+    ScormEngine.configure do |config|
+      config.host = "scorm.engine"
+      config.username = "admin"
+      config.password = "secret"
+    end
+  end
+
+  it "knows its host" do
+    expect(ScormEngine.configuration.host).to eq "scorm.engine"
+  end
+
+  it "knows its username" do
+    expect(ScormEngine.configuration.username).to eq "admin"
+  end
+
+  it "knows its password" do
+    expect(ScormEngine.configuration.password).to eq "secret"
+  end
+
+  it "knows its logger" do
+    expect(ScormEngine.configuration.logger).to be_a Logger
+  end
+
+  it "knows its log options" do
+    expect(ScormEngine.configuration.log_options).to eq({ headers: false, bodies: false })
+  end
+end

data/spec/scorm_engine/models/course_configuration_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe ScormEngine::Models::CourseConfiguration do
+  describe ".new_from_api" do
+    describe ":settings" do
+      it "a hash built from configurationItems" do
+        config = described_class.new_from_api(
+          "configurationItems" => [
+            { "id" => "Foo", "value" => "YES" },
+            { "id" => "Bar", "value" => "123" },
+          ]
+        )
+        expect(config.settings["Foo"]).to eq "YES"
+        expect(config.settings["Bar"]).to eq "123"
+      end
+    end
+  end
+end

data/spec/scorm_engine/models/course_import_spec.rb

@@ -0,0 +1,86 @@
+RSpec.describe ScormEngine::Models::CourseImport do
+  describe ".new_from_api" do
+    describe "when :importResult is present" do
+      let(:subject) { described_class.new_from_api("result" => "id123", "importResult" => { "status" => "RUNNING", "parserWarnings" => "watch out" }) }
+
+      it "sets the id" do
+        expect(subject.id).to eq "id123"
+      end
+
+      it "sets the status" do
+        expect(subject.status).to eq "RUNNING"
+      end
+
+      it "sets the course to nil" do
+        expect(subject.course).to eq nil
+      end
+
+      it "sets the parser_warnings" do
+        expect(subject.parser_warnings).to eq "watch out"
+      end
+
+      it "sets the parser_warnings to nil if not present" do
+        subject = described_class.new_from_api("importResult" => {})
+        expect(subject.parser_warnings).to eq nil
+      end
+    end
+
+    describe "when :importResult is absent" do
+      let(:subject) { described_class.new_from_api("jobId" => "id123", "status" => "COMPLETE", "course" => { "id" => "course123" }) }
+
+      it "sets the id" do
+        expect(subject.id).to eq "id123"
+      end
+
+      it "sets the status" do
+        expect(subject.status).to eq "COMPLETE"
+      end
+
+      it "sets the course if present" do
+        expect(subject.course).to be_a ScormEngine::Models::Course
+        expect(subject.course.id).to eq "course123"
+      end
+
+      it "sets the course to nil if absent" do
+        subject = described_class.new_from_api({})
+        expect(subject.course).to eq nil
+      end
+    end
+  end
+
+  describe "#running?" do
+    it "is true when status is RUNNING" do
+      subject = described_class.new_from_api("status" => "RUNNING")
+      expect(subject.running?).to eq true
+    end
+
+    it "is false when status is not RUNNING" do
+      subject = described_class.new_from_api("status" => "OOPS")
+      expect(subject.running?).to eq false
+    end
+  end
+
+  describe "#error?" do
+    it "is true when status is ERROR" do
+      subject = described_class.new_from_api("status" => "ERROR")
+      expect(subject.error?).to eq true
+    end
+
+    it "is false when status is not ERROR" do
+      subject = described_class.new_from_api("status" => "OOPS")
+      expect(subject.error?).to eq false
+    end
+  end
+
+  describe "#complete?" do
+    it "is true when status is COMPLETE" do
+      subject = described_class.new_from_api("status" => "COMPLETE")
+      expect(subject.complete?).to eq true
+    end
+
+    it "is false when status is not COMPLETTE" do
+      subject = described_class.new_from_api("status" => "OOPS")
+      expect(subject.complete?).to eq false
+    end
+  end
+end

data/spec/scorm_engine/models/course_spec.rb

@@ -0,0 +1,92 @@
+RSpec.describe ScormEngine::Models::Course do
+  describe ".new_from_api" do
+    describe ":title" do
+      it "is blank when title is blank" do
+        course = described_class.new_from_api(
+          "id" => "test"
+        )
+        expect(course.title).to eq ""
+      end
+
+      it "is blank when title is blank" do
+        course = described_class.new_from_api(
+          "id" => "test", "title" => ""
+        )
+        expect(course.title).to eq ""
+      end
+
+      it "is blank when title is literally 'Title'" do
+        course = described_class.new_from_api(
+          "id" => "test", "title" => "Title"
+        )
+        expect(course.title).to eq ""
+      end
+
+      it "is blank when title is literally 'Captivate E-Learning Course'" do
+        course = described_class.new_from_api(
+          "id" => "test", "title" => "Captivate E-Learning Course"
+        )
+        expect(course.title).to eq ""
+      end
+
+      it "is correct when title contains escaped HTML" do
+        course = described_class.new_from_api(
+          "id" => "test", "title" => "<b>The <a href="foo">Title</a></b>"
+        )
+        expect(course.title).to eq "The Title"
+      end
+
+      it "is correct when title contains unescaped HTML" do
+        course = described_class.new_from_api(
+          "id" => "test", "title" => "<b>The <a href='foo'>Title</a></b>"
+        )
+        expect(course.title).to eq "The Title"
+      end
+
+      it "is correct when title contains lots of white space" do
+        course = described_class.new_from_api(
+          "id" => "test", "title" => " The  \n\tTitle "
+        )
+        expect(course.title).to eq "The Title"
+      end
+    end
+
+    describe ":scaled_passing_score" do
+      it "is nil when rootActivity is blank" do
+        course = described_class.new_from_api(
+          "id" => "test"
+        )
+        expect(course.scaled_passing_score).to eq nil
+      end
+
+      it "is nil when rootActivity/children is blank" do
+        course = described_class.new_from_api(
+          "id" => "test", "rootActivity" => { "children" => [] }
+        )
+        expect(course.scaled_passing_score).to eq nil
+      end
+
+      it "is nil when rootActivity/children/scaledPassingScore is blank" do
+        course = described_class.new_from_api(
+          "id" => "test", "rootActivity" => { "children" => [{ "scaledPassingScore" => nil }] }
+        )
+        expect(course.scaled_passing_score).to eq nil
+      end
+
+      {
+        "0" => 0,
+        "0.5" => 50,
+        "1.0" => 100,
+        "2" => 2,
+        "100" => 100,
+      }.each do |value, score|
+        it "is #{score} when rootActivity/children/scaledPassingScore is '#{value}'" do
+          course = described_class.new_from_api(
+            "id" => "test", "rootActivity" => { "children" => [{ "scaledPassingScore" => value }] }
+          )
+          expect(course.scaled_passing_score).to eq score
+        end
+      end
+    end
+  end
+end

data/spec/scorm_engine/models/learner_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe ScormEngine::Models::Learner do
+  describe ".new_from_api" do
+    let(:learner) { described_class.new_from_api(
+      "id" => "learner-123",
+      "firstName" => "Bobby",
+      "lastName" => "Jones",
+    ) }
+
+    describe ":id" do
+      it "is set properly" do
+        expect(learner.id).to eq "learner-123"
+      end
+    end
+
+    describe ":first_name" do
+      it "is set properly" do
+        expect(learner.first_name).to eq "Bobby"
+      end
+    end
+
+    describe ":last_name" do
+      it "is set properly" do
+        expect(learner.last_name).to eq "Jones"
+      end
+    end
+  end
+end