scorm_engine 0.1.0

data/spec/scorm_engine/models/registration_activity_detail_spec.rb

@@ -0,0 +1,101 @@
+RSpec.describe ScormEngine::Models::RegistrationActivityDetail do
+  describe ".new_from_api" do
+    let(:options) { {
+      "id" => "activity-123",
+      "runtime" => {
+        "runtimeInteractions" => [
+          { "id" => "root-interaction-1" },
+          { "id" => "root-interaction-2" },
+        ],
+      },
+      "children" => [
+        {
+          "id" => "child-1",
+          "runtime" => {
+            "runtimeInteractions" => [
+              { "id" => "child-1-interaction-1" },
+              { "id" => "child-1-interaction-2" },
+            ],
+          },
+          "children" => [
+            {
+              "id" => "grandchild-1",
+              "runtime" => { "runtimeInteractions" => [] },
+            },
+          ],
+        },
+        {
+          "id" => "child-2",
+          "runtime" => {
+            "runtimeInteractions" => [
+              { "id" => "child-2-interaction-1" },
+            ],
+          },
+          "children" => [
+            {
+              "id" => "grandchild-2",
+              "runtime" => {
+                "runtimeInteractions" => [
+                  { "id" => "grandchild-1-interaction-1" },
+                  { "id" => "grandchild-1-interaction-2" },
+                ],
+              },
+            },
+            {
+              "id" => "grandchild-3",
+              "runtime" => {},
+            },
+          ],
+        },
+      ],
+    } }
+
+    let(:activity) { described_class.new_from_api(options) }
+
+    describe ":id" do
+      it "is set properly" do
+        expect(activity.id).to eq "activity-123"
+      end
+    end
+
+    describe ":children" do
+      it "is set properly" do
+        ids = activity.children.map(&:id)
+        expect(ids).to match_array %w[child-1 child-2]
+      end
+
+      it "is set properly for children" do
+        ids = activity.children.flat_map(&:children).map(&:id)
+        expect(ids).to match_array %w[grandchild-1 grandchild-2 grandchild-3]
+      end
+    end
+
+    describe ":runtime_interactions" do
+      it "is set properly" do
+        ids = activity.runtime_interactions.map(&:id)
+        expect(ids).to match_array %w[root-interaction-1 root-interaction-2]
+      end
+
+      it "is set properly for children" do
+        ids = activity.children.detect { |c| c.id == "child-1" }.runtime_interactions.map(&:id)
+        expect(ids).to match_array %w[child-1-interaction-1 child-1-interaction-2]
+      end
+
+      it "is set properly for grandchildren" do
+        child = activity.children.detect { |c| c.id == "child-2" }
+        ids = child.children.detect { |c| c.id == "grandchild-2" }.runtime_interactions.map(&:id)
+        expect(ids).to match_array %w[grandchild-1-interaction-1 grandchild-1-interaction-2]
+      end
+    end
+
+    describe "#all_runtime_interactions" do
+      it "returns all interactions" do
+        expect(activity.all_runtime_interactions.map(&:id)).to match_array %w[
+          root-interaction-1 root-interaction-2
+          child-1-interaction-1 child-1-interaction-2 child-2-interaction-1
+          grandchild-1-interaction-1 grandchild-1-interaction-2
+        ]
+      end
+    end
+  end
+end

data/spec/scorm_engine/models/registration_launch_history_spec.rb

@@ -0,0 +1,86 @@
+RSpec.describe ScormEngine::Models::RegistrationLaunchHistory do
+  describe ".new_from_api" do
+    let(:launch_history) { described_class.new_from_api(
+      "id" => "registration-456",
+      "instanceId" => 1.0,
+      "launchTime" => "07/25/2018 20:02:02 PM",
+      "launchTimeUtc" => "07/25/2018 20:02:02 PM",
+      "exitTime" => "07/25/2018 20:02:14 PM",
+      "exitTimeUtc" => "07/25/2018 20:02:14 PM",
+      "completionStatus" => "Incomplete",
+      "successStatus" => "Failed",
+      "lastRuntimeUpdate" => "07/25/2018 20:02:14 PM",
+      "lastRuntimeUpdateUtc" => "2018-07-25T20:01:58.000Z", # intentionally tweaked from what is really returned
+      "score" => { "scaled" => 93.0 },
+    )}
+
+    describe ":id" do
+      it "is set properly" do
+        expect(launch_history.id).to eq "registration-456"
+      end
+    end
+
+    describe ":score" do
+      it "is set properly" do
+        expect(launch_history.score).to eq 93.0
+      end
+
+      it "is left unset if not present" do
+        launch_history = described_class.new_from_api({})
+        expect(launch_history.score).to eq nil
+      end
+    end
+
+    describe ":total_seconds_tracked" do
+      it "is set properly when set in the root level with a trailing space" do
+        launch_history = described_class.new_from_api("totalSecondsTracked " => 123)
+        expect(launch_history.total_seconds_tracked).to eq 123
+      end
+
+      it "is set properly when set in the root level without a trailing space" do
+        launch_history = described_class.new_from_api("totalSecondsTracked" => 123)
+        expect(launch_history.total_seconds_tracked).to eq 123
+      end
+
+      it "is set properly when set in the score object with a trailing space" do
+        launch_history = described_class.new_from_api("score" => { "totalSecondsTracked " => 123 })
+        expect(launch_history.total_seconds_tracked).to eq 123
+      end
+
+      it "is set properly when set in the score object without a trailing space" do
+        launch_history = described_class.new_from_api("score" => { "totalSecondsTracked" => 123 })
+        expect(launch_history.total_seconds_tracked).to eq 123
+      end
+
+      it "is set to zero when it's negative" do
+        launch_history = described_class.new_from_api("totalSecondsTracked" => -9.223372036854776e+16)
+        expect(launch_history.total_seconds_tracked).to eq 0
+      end
+
+      it "is left unset if not present" do
+        launch_history = described_class.new_from_api({})
+        expect(launch_history.total_seconds_tracked).to eq nil
+      end
+    end
+
+    describe ":instance_id" do
+      it "is coerced to an integer" do
+        expect(launch_history.instance_id).to eq 1
+      end
+    end
+
+    %i[launch_time exit_time last_runtime_update].each do |attr|
+      describe ":#{attr}" do
+        it "is set properly in the UTC timezone" do
+          expect(launch_history.send(attr)).to be_a Time
+          expect(launch_history.send(attr).zone).to eq "UTC"
+        end
+
+        it "is left unset if not present" do
+          launch_history = described_class.new_from_api({})
+          expect(launch_history.send(attr)).to eq nil
+        end
+      end
+    end
+  end
+end

data/spec/scorm_engine/models/registration_runtime_interaction_spec.rb

@@ -0,0 +1,91 @@
+RSpec.describe ScormEngine::Models::RegistrationRuntimeInteraction do
+  describe ".new_from_api" do
+    let(:options) { {
+      "id" => "interaction-123",
+      "description" => "  foo \t bar \n baz  ",
+      "timestampUtc" => "2018-05-24T00:01:02.00Z",
+      "correctResponses" => %w[one two],
+      "learnerResponse" => "one",
+      "result" => "correct",
+      "weighting" => "3",
+      "latency" => "0012:34:59"
+    } }
+
+    let(:interaction) { described_class.new_from_api(options) }
+
+    describe ":id" do
+      it "is set properly" do
+        expect(interaction.id).to eq "interaction-123"
+      end
+    end
+
+    describe ":description" do
+      it "is set properly" do
+        expect(interaction.description).to eq "foo bar baz"
+      end
+
+      it "is set to nil if blank" do
+        interaction = described_class.new_from_api(options.merge("description" => " "))
+        expect(interaction.description).to eq nil
+      end
+
+      it "is set to nil if literal value 'null'" do
+        interaction = described_class.new_from_api(options.merge("description" => "null"))
+        expect(interaction.description).to eq nil
+      end
+    end
+
+    describe ":timestamp" do
+      it "is set properly" do
+        expect(interaction.timestamp.iso8601).to eq "2018-05-24T00:01:02Z"
+      end
+
+      it "is set to nil if blank" do
+        interaction = described_class.new_from_api(options.merge("timestampUtc" => ""))
+        expect(interaction.timestamp).to eq nil
+      end
+    end
+
+    describe ":correct_responses" do
+      it "is set properly" do
+        expect(interaction.correct_responses).to eq %w[one two]
+      end
+    end
+
+    describe ":learner_response" do
+      it "is set properly" do
+        expect(interaction.learner_response).to eq "one"
+      end
+    end
+
+    describe ":result" do
+      it "is set properly" do
+        expect(interaction.result).to eq "correct"
+      end
+    end
+
+    describe ":weighting" do
+      it "is set properly" do
+        expect(interaction.weighting).to eq "3"
+      end
+    end
+
+    describe ":latency" do
+      it "is set properly" do
+        expect(interaction.latency).to eq "0012:34:59"
+      end
+    end
+
+    describe "#latency_in_seconds" do
+      it "parses valid values" do
+        interaction = described_class.new_from_api("latency" => "0012:34:59")
+        expect(interaction.latency_in_seconds).to eq 45_299
+      end
+
+      it "returns zero for invalid values" do
+        interaction = described_class.new_from_api("latency" => "wat")
+        expect(interaction.latency_in_seconds).to eq 0
+      end
+    end
+  end
+end

data/spec/scorm_engine/models/registration_spec.rb

@@ -0,0 +1,82 @@
+RSpec.describe ScormEngine::Models::Registration do
+  describe ".new_from_api" do
+    let(:options) { {
+      "id" => "registration-456",
+      "score" => {
+        "scaled" => "3.14159",
+        "additionalProperties" => {},
+      },
+      "course" => {
+        "id" => "course-789",
+        "title" => "Golf 101",
+      },
+      "learner" => {
+        "id" => "learner-123",
+        "firstName" => "Bobby",
+        "lastName" => "Jones",
+      },
+    } }
+
+    let(:registration) { described_class.new_from_api(options) }
+
+    describe ":id" do
+      it "is set properly" do
+        expect(registration.id).to eq "registration-456"
+      end
+    end
+
+    describe ":score" do
+      it "is set properly" do
+        expect(registration.score).to be_a Numeric
+        expect(registration.score.round(2)).to eq 3.14
+      end
+
+      it "is left unset if not present" do
+        registration = described_class.new_from_api({})
+        expect(registration.score).to eq nil
+      end
+    end
+
+    describe ":completed_date" do
+      it "is set properly when key is in root level" do
+        registration = described_class.new_from_api(options.merge("completedDate" => "2018-05-24T00:01:02.000Z"))
+        expect(registration.completed_date).to be_a Time
+        expect(registration.completed_date.iso8601).to eq "2018-05-24T00:01:02Z"
+      end
+
+      it "is set properly when key is in score object" do
+        registration = described_class.new_from_api(options.merge("score" => { "completedDate" => "2018-05-24T00:01:02.000Z" }))
+        expect(registration.completed_date).to be_a Time
+        expect(registration.completed_date.iso8601).to eq "2018-05-24T00:01:02Z"
+      end
+
+      it "is left unset if not present" do
+        expect(registration.completed_date).to eq nil
+      end
+    end
+
+    describe ":course" do
+      it "is set properly" do
+        expect(registration.course).to be_a ScormEngine::Models::Course
+        expect(registration.course.id).to eq "course-789"
+      end
+
+      it "is left unset if not present" do
+        registration = described_class.new_from_api({})
+        expect(registration.course).to eq nil
+      end
+    end
+
+    describe ":learner" do
+      it "is set properly" do
+        expect(registration.learner).to be_a ScormEngine::Models::Learner
+        expect(registration.learner.id).to eq "learner-123"
+      end
+
+      it "is left unset if not present" do
+        registration = described_class.new_from_api({})
+        expect(registration.learner).to eq nil
+      end
+    end
+  end
+end

data/spec/scorm_engine/utils_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe ScormEngine::Utils do
+  describe ".sanitized_text" do
+    it "removes unescaped HTML" do
+      expect(described_class.sanitized_text("<b class='world'>Hello</b>")).to eq "Hello"
+    end
+
+    it "strips and squeezes all white space" do
+      expect(described_class.sanitized_text(" a  b\n\r\t c ")).to eq "a b c"
+    end
+
+    pending "encodes string to utf8"
+    pending "replaces invalid utf8"
+    pending "replaces undefined utf8"
+  end
+end

data/spec/scorm_engine/version_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe ScormEngine do
+  it "has a version number" do
+    expect(ScormEngine::VERSION).not_to be nil
+  end
+end

data/spec/scorm_engine_spec.rb

@@ -0,0 +1,2 @@
+RSpec.describe ScormEngine do
+end

data/spec/spec_helper.rb

@@ -0,0 +1,47 @@
+require "bundler/setup"
+require "dotenv"
+require "pry"
+require "scorm_engine"
+
+# Ensure we're picking up only the test scorm settings
+Dotenv.load(".env.test")
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # Tag all groups and examples to use VCR
+  config.define_derived_metadata do |metadata|
+    metadata[:vcr] = true
+  end
+end
+
+# Require every spec support file
+Dir[File.join(File.dirname(__FILE__), "support", "**/*.rb")].each do |file|
+  require file
+end

data/spec/support/scorm_engine.rb

@@ -0,0 +1,72 @@
+module ScormEngineHelpers
+  #
+  # If a real scorm engine is available this method will disable VCR and
+  # execute the passed block.  It is useful for when we need to ensure certain
+  # records are present in SCORM engine, but we do not want them recorded as
+  # the act of recording would break later expectations. That is if we record
+  # importing a course and play it back other tests that expect the actual
+  # record to exist in SCORM will fail.
+  #
+  def against_real_scorm_engine
+    return unless scorm_engine_is_available?
+
+    cassette = VCR.eject_cassette
+    VCR.turned_off do
+      yield
+    end
+    VCR.insert_cassette(cassette.name, cassette.instance_variable_get(:@options))
+  end
+
+  #
+  # Check to see if a scorm engine is available. Probably true while developing
+  # locally, definitely not true in Travis.
+  #
+  def scorm_engine_is_available?
+    ENV["SCORM_ENGINE_IS_AVAILABLE"] == "true"
+  end
+
+  #
+  # Ensure that the specified course exists in SCORM engine. Will import course
+  # if not present.
+  #
+  def ensure_course_exists(options = {})
+    response = options[:client].get_courses(course_id: options[:course_id])
+    return if response&.results&.first&.id == options[:course_id]
+    import_course(options)
+  end
+
+  #
+  # Attempt to import a course to SCORM engine.
+  #
+  def import_course(options = {})
+    options = { key: "RuntimeBasicCalls_SCORM20043rdEdition", may_create_new_version: true }.merge(options)
+
+    url = "https://github.com/phallstrom/scorm_engine/raw/master/spec/fixtures/zip/#{options[:key]}.zip"
+
+    import = options[:client].post_course_import(course_id: options[:course_id], url: url, may_create_new_version: options[:may_create_new_version])
+
+    if import.success?
+      loop do
+        import = options[:client].get_course_import(id: import.result.id)
+        break unless import.success? && import.result.running?
+        sleep 5
+      end
+    end
+
+    import
+  end
+
+  #
+  # Ensure that the specified registration exists in SCORM engine. Course
+  # must exist first.
+  #
+  def ensure_registration_exists(options = {})
+    response = options[:client].get_registration_exists(registration_id: options[:registration_id])
+    return if response&.result
+    options[:client].post_registration(options)
+  end
+end
+
+RSpec.configure do |c|
+  c.include ScormEngineHelpers
+end