click_session 0.0.1

data/spec/click_session/async_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'click_session/configuration'
+require 'click_session/exceptions'
+require 'support/test_unit_model'
+
+describe ClickSession::Async do
+  describe "#run" do
+    let(:model) {
+      create(:test_unit_model)
+    }
+
+    describe "guard clauses" do
+      context "when no callback urls has been configured" do
+        it "raises a friendly error" do
+          async_click_session = ClickSession::Async.new(model)
+
+          expect { async_click_session.run }.to raise_error(ClickSession::ConfigurationError)
+        end
+      end
+    end
+
+    context 'when processing is successful' do
+      before do
+        mock_configuration_model_class_with(model)
+      end
+
+      before :each do
+        mock_configuration_callback_urls
+        disable_screenshots
+      end
+
+      it "saves the session_state" do
+        async_click_session = ClickSession::Async.new(model)
+
+        expect { async_click_session.run }.
+          to change { ClickSession::SessionState.count }.by(1)
+      end
+
+      it "returns a serialized OK response without the model" do
+        async_click_session = ClickSession::Async.new(model)
+
+        response = async_click_session.run
+
+        expect(response[:id]).to be_a(Integer)
+        expect(response[:status][:success]).to be(true)
+        expect(response[:data]).to eql(model.as_json)
+      end
+    end
+  end
+
+  def mock_configuration_callback_urls
+    allow(ClickSession.configuration).
+      to receive(:success_callback_url).
+      and_return("http://success.callback.url")
+
+    allow(ClickSession.configuration).
+      to receive(:failure_callback_url).
+      and_return("http://failure.callback.url")
+  end
+
+  def disable_screenshots
+    allow(ClickSession.configuration).
+      to receive(:screenshot_enabled?).
+      and_return(false)
+  end
+end

data/spec/click_session/click_session_processor_spec.rb

@@ -0,0 +1,292 @@
+require 'spec_helper'
+require 'click_session/configuration'
+require 'support/test_unit_model'
+require 'support/dummy_web_runner'
+
+describe ClickSession::ClickSessionProcessor do
+  describe "#process" do
+    let(:model) {
+      create(:test_unit_model)
+    }
+
+    let(:session_state) do
+      ClickSession::SessionState.new(model: model)
+    end
+
+    before do
+      mock_model_class_in_in_configuration(model)
+    end
+
+    context 'when processing is successful' do
+      before do
+        @web_runner_processor_mock = mock_succesful_web_runner_processor
+        @notifier_mock = mock_for_notifier
+      end
+
+      it "processes the model" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        click_session_processor.process
+
+        expect(@web_runner_processor_mock).to have_received(:process).with(model)
+      end
+
+      it "changes the state of the session_state to 'processed'" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        click_session_processor.process
+
+        expect(ClickSession::SessionState.last.state_name).to eql(:processed)
+      end
+
+      it "returns the session_state" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        response = click_session_processor.process
+
+        expect(response).to be_a(ClickSession::SessionState)
+      end
+
+      it "sends a notification of the success" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        response = click_session_processor.process
+
+        expect(@notifier_mock).
+          to have_received(:session_successful).
+          with(session_state)
+      end
+
+
+      it "guards against faulty screenshot configurations" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock,
+          screenshot_enabled: true,
+          screnshot: nil
+        )
+
+        expect { click_session_processor.process }.to raise_error(ClickSession::ConfigurationError)
+      end
+
+      context 'when saving screenshots is enabled' do
+        it "records the url of the screenshot" do
+          click_session_processor = ClickSession::ClickSessionProcessor.new(
+            session_state,
+            @web_runner_processor_mock,
+            @notifier_mock,
+            screenshot_enabled: true,
+            screenshot_options: {
+              s3_bucket: "unit-s3",
+              s3_key_id: "unit-s3-key",
+              s3_access_key: "unit_s3_access_key"
+            }
+          )
+
+          response = click_session_processor.process
+
+          expect(@web_runner_processor_mock).to have_received(:save_screenshot)
+          expect(ClickSession::SessionState.last.screenshot_url).to be_a(String)
+        end
+      end
+
+      context "when saving screenshot is disabled" do
+        it "does not save the screenshot" do
+          click_session_processor = ClickSession::ClickSessionProcessor.new(
+            session_state,
+            @web_runner_processor_mock,
+            @notifier_mock
+          )
+
+          response = click_session_processor.process
+
+          expect(@web_runner_processor_mock).not_to have_received(:save_screenshot)
+          expect(ClickSession::SessionState.last.screenshot_url).to be_nil
+        end
+      end
+    end
+
+    context 'when processing fails' do
+      before do
+        @web_runner_processor_mock = mock_failing_web_runner_processor
+        @notifier_mock = mock_for_notifier
+      end
+
+      it "processes the model" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        begin
+          click_session_processor.process
+        rescue ClickSession::TooManyRetriesError => e
+          expect(@web_runner_processor_mock).to have_received(:process).with(model)
+        end
+      end
+
+      it "changes the state of the session_state to 'failed_to_process'" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        begin
+          click_session_processor.process
+        rescue ClickSession::TooManyRetriesError => e
+          expect(ClickSession::SessionState.last.state_name).to eql(:failed_to_process)
+        end
+      end
+
+      it "raises a TooManyRetriesError" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        expect { click_session_processor.process }.
+          to raise_error(ClickSession::TooManyRetriesError)
+      end
+
+      it "sends a notification of the failure" do
+        click_session_processor = ClickSession::ClickSessionProcessor.new(
+          session_state,
+          @web_runner_processor_mock,
+          @notifier_mock
+        )
+
+        begin
+          click_session_processor.process
+        rescue ClickSession::TooManyRetriesError => e
+          expect(@notifier_mock).
+            to have_received(:session_failed).
+            with(session_state)
+        end
+      end
+
+      context 'when saving screenshots is enabled' do
+        it "records the url of the screenshot" do
+          click_session_processor = ClickSession::ClickSessionProcessor.new(
+            session_state,
+            @web_runner_processor_mock,
+            @notifier_mock,
+            screenshot_enabled: true,
+            screenshot_options: {
+              s3_bucket: "unit-s3",
+              s3_key_id: "unit-s3-key",
+              s3_access_key: "unit_s3_access_key"
+            }
+          )
+
+          begin
+            click_session_processor.process
+          rescue ClickSession::TooManyRetriesError => e
+            expect(@web_runner_processor_mock).to have_received(:save_screenshot)
+            expect(ClickSession::SessionState.last.screenshot_url).to be_a(String)
+          end
+        end
+      end
+
+      context "when saving screenshot is disabled" do
+        it "does not save the screenshot" do
+          click_session_processor = ClickSession::ClickSessionProcessor.new(
+            session_state,
+            @web_runner_processor_mock,
+            @notifier_mock
+          )
+
+          begin
+            click_session_processor.process
+          rescue ClickSession::TooManyRetriesError => e
+            expect(@web_runner_processor_mock).not_to have_received(:save_screenshot)
+            expect(ClickSession::SessionState.last.screenshot_url).to be_nil
+          end
+        end
+      end
+    end
+
+    def mock_succesful_web_runner_processor
+      processor_stub = DummyWebRunner.new
+      web_runner_processor_mock = ClickSession::WebRunnerProcessor.new(processor_stub)
+
+      allow(web_runner_processor_mock).
+        to receive(:process).
+        with(model).
+        and_return(model)
+
+      allow(web_runner_processor_mock).
+        to receive(:save_screenshot).
+        and_return("http://url.to/success-screenshot")
+
+      allow(ClickSession::WebRunnerProcessor).
+        to receive(:new).
+        and_return(web_runner_processor_mock)
+
+      web_runner_processor_mock
+    end
+
+    def mock_failing_web_runner_processor
+      processor_stub = DummyWebRunner.new
+      web_runner_processor_mock = ClickSession::WebRunnerProcessor.new(processor_stub)
+
+      allow(web_runner_processor_mock).
+        to receive(:process).
+        with(model).
+        and_raise(ClickSession::TooManyRetriesError, "Error in unit test")
+
+      allow(web_runner_processor_mock).
+        to receive(:save_screenshot).
+        and_return("http://url.to/failure-screenshot")
+
+      allow(ClickSession::WebRunnerProcessor).
+        to receive(:new).
+        and_return(web_runner_processor_mock)
+
+      web_runner_processor_mock
+    end
+
+    def mock_model_class_in_in_configuration(model_stub)
+      model_double = class_double(TestUnitModel)
+
+      # Mock the model_class from the configuration
+      allow(model_double).
+        to receive(:find_by_id).
+        with(model_stub.id).
+        and_return(model_stub)
+
+      allow(ClickSession.configuration).
+        to receive(:model_class).
+        and_return(model_double)
+    end
+
+    def mock_for_notifier
+      notifier_mock = ClickSession::Notifier.new
+
+      allow(notifier_mock).to receive(:session_failed)
+      allow(notifier_mock).to receive(:session_successful)
+      allow(notifier_mock).to receive(:rescued_error)
+
+      notifier_mock
+    end
+  end
+end

data/spec/click_session/configuration_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+require 'support/click_session_runner'
+
+describe ClickSession::Configuration do
+  context 'no congifuration given' do
+    before do
+      ClickSession.configure
+    end
+
+    it 'provides defaults' do
+      expect(ClickSession.configuration.processor_class).to eq(ClickSessionRunner)
+      expect(ClickSession.configuration.serializer_class).to eq(ClickSession::WebhookModelSerializer)
+      expect(ClickSession.configuration.notifier_class).to eq(ClickSession::Notifier)
+      expect(ClickSession.configuration.driver_client).to eq(:poltergeist)
+      expect(ClickSession.configuration.screenshot_enabled?).to eq(false)
+      expect{ ClickSession.configuration.screenshot }.to raise_error
+    end
+
+    it 'raises a helpful error if model_class_name is undefined' do
+      expect { ClickSession.configuration.model_class }.
+        to raise_error(NameError, %r{https://github\.com/talltorp/click_session})
+    end
+
+    it 'raises a helpful error if ClickSessionRunner is undefined' do
+      allow(Kernel).to receive_messages(const_defined?: false)
+
+      expect { ClickSession.configuration.processor_class }.
+        to raise_error(NameError, %r{https://github\.com/talltorp/click_session})
+    end
+  end
+
+  context 'with config block' do
+    after do
+      ClickSession.configure
+    end
+
+    it "stores the model_class" do
+      class DummyModelClass
+      end
+
+      ClickSession.configure do | config |
+        config.model_class = DummyModelClass
+      end
+
+      expect(ClickSession.configuration.model_class).to eq(DummyModelClass)
+    end
+
+    it "stores the processor_class" do
+      class DummyProcessorClass
+      end
+
+      ClickSession.configure do | config |
+        config.processor_class = DummyProcessorClass
+      end
+
+      expect(ClickSession.configuration.processor_class).to eq(DummyProcessorClass)
+    end
+
+    it "stores the serializer_class" do
+      class DummySerializerClass
+      end
+
+      ClickSession.configure do | config |
+        config.serializer_class = DummySerializerClass
+      end
+
+      expect(ClickSession.configuration.serializer_class).to eq(DummySerializerClass)
+    end
+
+    it "stores the notifier_class" do
+      class DummyNotifierClass < ClickSession::Notifier
+      end
+
+      ClickSession.configure do | config |
+        config.notifier_class = DummyNotifierClass
+      end
+
+      expect(ClickSession.configuration.notifier_class).to eq(DummyNotifierClass)
+    end
+
+    context 'when the provided notifier_class does not extend the base Notifier' do
+      it "raises an helpful message" do
+        class SerializerNotExtendingBaseNotifer
+          def session_successful
+          end
+        end
+
+        ClickSession.configure do | config |
+          config.notifier_class = SerializerNotExtendingBaseNotifer
+        end
+
+        expect{ ClickSession.configuration.notifier_class }.
+          to raise_error(ArgumentError)
+      end
+    end
+
+    it "stores the driver_client" do
+      ClickSession.configure do | config |
+        config.driver_client = :selenium
+      end
+
+      expect(ClickSession.configuration.driver_client).to eq(:selenium)
+    end
+
+    it "stores the enable_screenshot flag" do
+      ClickSession.configure do | config |
+        config.enable_screenshot = true
+      end
+
+      expect(ClickSession.configuration.screenshot_enabled?).to eq(true)
+    end
+
+    context 'with complete screenshot information' do
+      it "stores the screenshot information" do
+        ClickSession.configure do | config |
+          config.screenshot = {
+            s3_bucket: "unit-bucket",
+            s3_key_id: "unit-key-id",
+            s3_access_key: "unit-access-key",
+          }
+        end
+
+        expect(ClickSession.configuration.screenshot).not_to be_nil
+      end
+    end
+
+    context 'with incomplete screenshot information' do
+      context 'with no :s3_bucket' do
+        it "raises an ArgumentError" do
+          expect do
+            ClickSession.configure do | config |
+              config.screenshot = {
+                s3_key_id: "unit-key-id",
+                s3_access_key: "unit-access-key",
+              }
+            end
+          end.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'with no :s3_key_id' do
+        it "raises an ArgumentError" do
+          expect do
+            ClickSession.configure do | config |
+              config.screenshot = {
+                s3_bucket: "unit-bucket",
+                s3_access_key: "unit-access-key",
+              }
+            end
+          end.to raise_error(ArgumentError)
+        end
+      end
+
+      context 'with no :s3_access_key' do
+        it "raises an ArgumentError" do
+          expect do
+            ClickSession.configure do | config |
+              config.screenshot = {
+                s3_bucket: "unit-bucket",
+                s3_key_id: "unit-key-id",
+              }
+            end
+          end.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end

data/spec/click_session/failure_status_reporter_spec.rb

@@ -0,0 +1,87 @@
+require "spec_helper"
+require "click_session/configuration"
+require "support/test_unit_model"
+
+describe ClickSession::FailureStatusReporter do
+  describe "#report" do
+    let(:model) do
+      create(:test_unit_model)
+    end
+
+    before do
+      stub_notifier_in_configuration
+    end
+
+    it "rejects shippings not processed" do
+      session_state = build_session_state_in_not_processed_state
+      status_reporter = ClickSession::FailureStatusReporter.new
+
+      expect { status_reporter.report(session_state) }.
+        to raise_error(ArgumentError)
+    end
+
+    it "rejects shippings successfully processed" do
+      session_state = build_session_state_in_successfully_processed_state
+      status_reporter = ClickSession::FailureStatusReporter.new
+
+      expect { status_reporter.report(session_state) }.
+        to raise_error(ArgumentError)
+    end
+
+    it "reports with an ERROR status" do
+      stub_notifier_in_configuration
+      session_state = build_session_state_in_failed_state
+      webhook_stub = ClickSession::Webhook.new("failure.url")
+      allow(webhook_stub).to receive(:call)
+
+      status_reporter = ClickSession::FailureStatusReporter.new(
+        webhook_stub
+      )
+
+      status_reporter.report(session_state)
+
+      expect(webhook_stub).
+        to have_received(:call).
+        with({
+          id: session_state.id,
+          status: {
+            success: false,
+            message: "See error logs"
+          }
+        })
+    end
+
+    def stub_notifier_in_configuration
+      notifier_double = class_double(ClickSession::Notifier)
+      notifier_stub = ClickSession::Notifier.new
+
+      # Stub the methods
+      allow(notifier_stub).
+        to receive(:session_reported)
+
+      # Add the stub to the double
+      allow(notifier_double).
+        to receive(:new).
+        and_return(notifier_stub)
+
+      # Make the configuration return our double
+      allow(ClickSession.configuration).
+        to receive(:notifier_class).
+        and_return(notifier_double)
+
+      notifier_stub
+    end
+
+    def build_session_state_in_successfully_processed_state
+      ClickSession::SessionState.create(state: 1, model_record: model.id)
+    end
+
+    def build_session_state_in_failed_state
+      ClickSession::SessionState.create(state: 2, model_record: model.id)
+    end
+
+    def build_session_state_in_not_processed_state
+      ClickSession::SessionState.create(state: 0, model_record: model.id)
+    end
+  end
+end

data/spec/click_session/notifier_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'support/test_unit_model'
+
+describe ClickSession::Notifier do
+  describe "#session_successful" do
+    it "logs success information about the click_session to stdout" do
+      session_state = ClickSession::SessionState.create({
+        state: 1,
+        model: build(:test_unit_model)
+      })
+      notifier = ClickSession::Notifier.new
+
+      expect { notifier.session_successful(session_state) }.
+        to output(/SUCCESS(.*)#{session_state.id}/).
+        to_stdout
+    end
+  end
+
+  describe "#session_failed" do
+    it "logs failure information about the click_session to stdout" do
+      session_state = ClickSession::SessionState.create({
+        state: 2,
+        model: build(:test_unit_model)
+      })
+      notifier = ClickSession::Notifier.new
+
+      expect { notifier.session_failed(session_state) }.
+        to output(/FAILURE(.*)#{session_state.id}/).
+        to_stderr
+    end
+  end
+
+  describe "#session_reported" do
+    it "logs report success information about the click_session to stdout" do
+      session_state = ClickSession::SessionState.create({
+        state: 1,
+        model: build(:test_unit_model)
+      })
+      notifier = ClickSession::Notifier.new
+
+      expect { notifier.session_reported(session_state) }.
+        to output(/REPORTED(.*)#{session_state.id}/).
+        to_stdout
+    end
+  end
+
+  describe "#session_failed_to_report" do
+    it "logs that the report failed for the click_session to stdout" do
+      session_state = ClickSession::SessionState.create({
+        state: 2,
+        model: build(:test_unit_model)
+      })
+      notifier = ClickSession::Notifier.new
+
+      expect { notifier.session_failed_to_report(session_state) }.
+        to output(/REPORT_FAIL(.*)#{session_state.id}/).
+        to_stderr
+    end
+  end
+
+  describe "#rescued_error" do
+    it "logs the exception to stdout" do
+      exception = ArgumentError.new("unit argument error")
+
+      notifier = ClickSession::Notifier.new
+
+      expect { notifier.rescued_error(exception) }.
+        to output(/ArgumentError/).
+        to_stdout
+    end
+  end
+end