click_session 0.0.1

data/spec/click_session/response_serializer_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require "click_session/configuration"
+require 'support/test_unit_model'
+
+describe ClickSession::ResponseSerializer do
+  let(:session_state) { ClickSession::SessionState.create }
+
+  let(:model) {
+    create(:test_unit_model)
+  }
+
+  describe "#serialize_success" do
+    before do
+      mock_configuration_model_class_with(model)
+    end
+
+    context 'With the default serializer' do
+      it "returns success meta data with the model serialized" do
+        session_state.model = model
+        response_serializer = ClickSession::ResponseSerializer.new
+
+        response = response_serializer.serialize_success(session_state)
+
+        expect(response).to eql({
+          id: session_state.id,
+          status: {
+            success: true
+          },
+          data: model.as_json
+        })
+      end
+    end
+  end
+
+  describe "#serialize_failure" do
+    it "returns failure meta data and no serialized model" do
+      session_state.model = model
+      response_serializer = ClickSession::ResponseSerializer.new
+
+      response = response_serializer.serialize_failure(session_state)
+
+      expect(response).to eql({
+        id: session_state.id,
+        status: {
+          success: false
+        }
+      })
+    end
+  end
+end

data/spec/click_session/s3_file_uploader_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe ClickSession::S3FileUploader do
+  describe "#upload_file_from"
+    it "returns the full url to the uploaded file" do
+      file_name = "unit-identifier-123.png"
+      key = "unit_key"
+      secret = "unit_secret"
+      bucket = "unit_bucket_name"
+
+      s3_connection = ClickSession::S3Connection.new(
+          key,
+          secret,
+          bucket
+        )
+      allow(s3_connection).
+        to receive(:upload_from_filesystem_to_bucket)
+
+      uploader = ClickSession::S3FileUploader.new(s3_connection)
+      screenshot_url = uploader.upload_file(file_name)
+
+      expect(screenshot_url).to eql("https://s3.amazonaws.com/#{bucket}/#{file_name}")
+    end
+end

data/spec/click_session/session_state_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "click_session/configuration"
+require 'support/test_unit_model'
+
+describe ClickSession::SessionState do
+  let(:model) { create(:test_unit_model) }
+
+  it { should validate_presence_of(:model_record) }
+
+  describe "#webhook_attempt_failed" do
+    it "increments the number of attempts" do
+      execution_state = ClickSession::SessionState.new
+
+      execution_state.webhook_attempt_failed
+
+      expect(execution_state.webhook_attempts).to eql(1)
+    end
+  end
+
+  describe "#model" do
+    context 'When model_class has been configured' do
+      before do
+        mock_configuration_model_class_with(model)
+      end
+
+      context 'with id to the record' do
+        it "returns the active record for the configured model_name" do
+          session_state = ClickSession::SessionState.create(model: model.id)
+
+          expect(session_state.model).to be_a(TestUnitModel)
+        end
+      end
+
+      context 'with an actual active record class' do
+        it "returns the active record for the configured model_name" do
+          session_state = ClickSession::SessionState.create(model: model)
+
+          expect(session_state.model).to be_a(TestUnitModel)
+        end
+      end
+
+      context 'When model passed is new' do
+        it "saves the model along with the session state" do
+          allow(model).to receive(:save!)
+          allow(model).to receive(:new_record?).and_return(true)
+
+          session_state = ClickSession::SessionState.create(model: model)
+
+          expect(model).to have_received(:save!)
+        end
+      end
+    end
+  end
+end

data/spec/click_session/status_reporter_spec.rb

@@ -0,0 +1,199 @@
+require "spec_helper"
+require "click_session/configuration"
+require 'support/test_unit_model'
+
+describe ClickSession::StatusReporter do
+  describe "#report" do
+    let(:session_state) { build_session_state_in_processed_state }
+    let(:model) { create(:test_unit_model) }
+
+    before :each do
+      @notifier_stub = stub_notifier_in_configuration
+
+      mock_configuration_model_class_with(model)
+    end
+
+    context 'when the reporting endpoint is online' do
+      it "reports the successfull order back" do
+        status_reporter = ClickSession::SuccessfulStatusReporter.new(
+          ok_webhook_stub
+        )
+
+        expect { status_reporter.report(session_state) }.
+          not_to raise_error
+      end
+
+      it "changes the state to 'success_reported'" do
+        status_reporter = ClickSession::SuccessfulStatusReporter.new(
+          ok_webhook_stub
+        )
+
+        status_reporter.report(session_state)
+
+        expect(session_state.success_reported?).to eql(true)
+      end
+
+      it "notifies about the successful reporting" do
+          status_reporter = ClickSession::SuccessfulStatusReporter.new(
+            ok_webhook_stub
+          )
+
+          status_reporter.report(session_state)
+
+          expect(@notifier_stub).
+            to have_received(:session_reported).
+            with(session_state)
+        end
+
+      context 'with a serializer_class in the configuration' do
+        it "serializes the response with the user defined serializer" do
+          class MyDefinedSerializer < ClickSession::WebhookModelSerializer
+            def serialize(model)
+              {
+                user_defined: "Serializer"
+              }
+            end
+          end
+
+          serializer_double = double(MyDefinedSerializer)
+          serializer_stub = MyDefinedSerializer.new
+
+          # Add the stub to the double
+          allow(serializer_double).
+            to receive(:new).
+            and_return(serializer_stub)
+
+          # Make the configuration return our double
+          allow(ClickSession.configuration).
+            to receive(:serializer_class).
+            and_return(serializer_double)
+
+          webhook_stub = ClickSession::Webhook.new("a-unit-test-web-hook.url")
+          allow(webhook_stub).
+            to receive(:call)
+
+          status_reporter = ClickSession::SuccessfulStatusReporter.new(
+            webhook_stub
+          )
+
+          status_reporter.report(session_state)
+
+          expect(webhook_stub).
+            to have_received(:call).
+            with( {
+              id: session_state.id,
+              status: {
+                success: true
+              },
+              data:{
+                user_defined: "Serializer"
+               }
+            } )
+        end
+      end
+    end
+
+    context 'when the reporting endpoint is offline' do
+      it "leaves the state in 'processed'" do
+        status_reporter = ClickSession::SuccessfulStatusReporter.new(
+          failing_webhook_stub
+        )
+
+        status_reporter.report(session_state)
+
+        expect(session_state.processed?).to eql(true)
+      end
+
+      it "notifies about the rescued error" do
+        status_reporter = ClickSession::SuccessfulStatusReporter.new(
+          failing_webhook_stub
+        )
+
+        status_reporter.report(session_state)
+
+        expect(@notifier_stub).to have_received(:rescued_error).once
+      end
+
+      context 'when the retry threshold has been reached' do
+        it "notifies the status_notifier about the threshold" do
+          session_state.webhook_attempts = 4
+
+          status_reporter = ClickSession::SuccessfulStatusReporter.new(
+            failing_webhook_threshold_reached_stub
+          )
+
+          status_reporter.report(session_state)
+
+          expect(@notifier_stub).to have_received(:rescued_error).once
+
+          expect(@notifier_stub).
+            to have_received(:session_failed_to_report).
+            with(session_state)
+        end
+      end
+    end
+
+    def ok_webhook_stub
+      unless @webhook
+        @webhook = ClickSession::Webhook.new("a-unit-test-web-hook.url")
+        expect(@webhook).
+          to receive(:call).
+          with(anything)
+      end
+      @webhook
+    end
+
+    def failing_webhook_stub
+      unless @webhook
+        @webhook = ClickSession::Webhook.new("a-unit-test-web-hook.url")
+        expect(@webhook).
+          to receive(:call).
+          with(anything).
+          and_raise(StandardError)
+      end
+      @webhook
+    end
+
+    def failing_webhook_threshold_reached_stub
+      unless @webhook
+        @webhook = ClickSession::Webhook.new("a-unit-test-web-hook.url")
+        expect(@webhook).
+          to receive(:call).
+          with(anything).
+          and_raise(StandardError)
+      end
+      @webhook
+    end
+
+    def stub_notifier_in_configuration
+      notifier_double = double(ClickSession::Notifier)
+      notifier_stub = ClickSession::Notifier.new
+
+      # Stub the method
+      allow(notifier_stub).
+        to receive(:session_failed_to_report)
+
+      allow(notifier_stub).
+        to receive(:session_reported)
+
+      allow(notifier_stub).
+        to receive(:rescued_error)
+
+      # 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_processed_state
+      ClickSession::SessionState.create(state: 1, model_record: model.id)
+    end
+  end
+end

data/spec/click_session/successful_status_reporter_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+require "click_session/configuration"
+require 'support/test_unit_model'
+
+describe ClickSession::SuccessfulStatusReporter do
+  describe "#report" do
+    let(:model) { create(:test_unit_model) }
+
+    before do
+      stub_notifier_in_configuration
+      mock_configuration_model_class_with(model)
+    end
+
+    it "rejects shippings not processed" do
+      session_state = build_session_state_in_not_processed_state
+      status_reporter = ClickSession::SuccessfulStatusReporter.new
+
+      expect { status_reporter.report(session_state) }.
+        to raise_error(ArgumentError)
+    end
+
+    it "rejects shippings which have failed" do
+      session_state = build_session_state_in_failed_state
+      status_reporter = ClickSession::SuccessfulStatusReporter.new
+
+      expect { status_reporter.report(session_state) }.
+        to raise_error(ArgumentError)
+    end
+
+    it "reports with an OK status" do
+      session_state = build_session_state_in_processed_state
+      webhook_stub = ClickSession::Webhook.new("success.url")
+      allow(webhook_stub).to receive(:call)
+
+      status_reporter = ClickSession::SuccessfulStatusReporter.new(
+        webhook_stub
+      )
+
+      status_reporter.report(session_state)
+
+      expect(webhook_stub).
+        to have_received(:call).
+        with({
+          id: session_state.id,
+          status: {
+            success: true
+          },
+          data: session_state.model.as_json
+        })
+    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_not_processed_state
+      ClickSession::SessionState.create(state: 0, model_record: model.id)
+    end
+
+    def build_session_state_in_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
+  end
+end

data/spec/click_session/sync_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+require 'click_session/configuration'
+require 'support/test_unit_model'
+
+describe ClickSession::Sync do
+  describe "#run" do
+
+    let(:model) { create(:test_unit_model) }
+
+    before do
+      @notifier_stub = stub_notifier_in_configuration
+      mock_configuration_model_class_with(model)
+
+      processor_stub = ClickSession::WebRunner.new
+      mock_configuration_processor_class_with(processor_stub)
+      @web_runner_processor_stub = stub_web_runner_processor_with( processor_stub )
+    end
+
+    context 'when processing is successful' do
+      before :each do
+        click_session_processor_mock = mock_click_session_processor_with(
+          @web_runner_processor_stub,
+          @notifier_stub
+        )
+
+        expect_any_instance_of(ClickSession::SessionState).
+          to receive(:reported_back!)
+
+        disable_screenshots
+      end
+
+      it "saves the session_state" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        expect { sync_click_session.run }.
+          to change { ClickSession::SessionState.count }.by(1)
+      end
+
+      it "processes the session" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        sync_click_session.run
+
+        expect(ClickSession::ClickSessionProcessor).
+          to have_received(:new).
+          with(
+            ClickSession::SessionState,
+            @web_runner_processor_stub,
+            @notifier_stub,
+            anything
+          )
+      end
+
+      context 'with screenshot is enabled' do
+        it "passes the configuration on to the ClickSessionRunner" do
+          screenshot_configuration = {
+              s3_bucket: "unit-s3",
+              s3_key_id: "unit-s3-key",
+              s3_access_key: "unit_s3_access_key"
+            }
+
+          allow(ClickSession.configuration).
+            to receive(:screenshot_enabled?).
+            and_return(true)
+
+          allow(ClickSession.configuration).
+            to receive(:screenshot).
+            and_return(screenshot_configuration)
+
+          sync_click_session = ClickSession::Sync.new(model)
+
+          sync_click_session.run
+
+          expect(ClickSession::ClickSessionProcessor).
+            to have_received(:new).
+            with(
+              ClickSession::SessionState,
+              @web_runner_processor_stub,
+              @notifier_stub,
+              {
+                screenshot_enabled: true,
+                screenshot_options: screenshot_configuration
+              }
+            )
+        end
+      end
+
+      it "uses the web_runner and notifier from the configuration" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        sync_click_session.run
+
+        expect(ClickSession.configuration).to have_received(:notifier_class)
+        expect(ClickSession.configuration).to have_received(:processor_class)
+      end
+
+      it "changes the state of the click_session to 'success_reported'" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        sync_click_session.run
+
+        # Expectation is in the 'before' method
+      end
+
+      it "returns a serialized OK response with the model" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        response = sync_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
+
+    context 'when processing fails' do
+      before :each do
+        mock_click_session_processor_and_raise_error(
+          @web_runner_processor_stub,
+          @notifier_stub
+        )
+
+        expect_any_instance_of(ClickSession::SessionState).
+          to receive(:reported_back!)
+
+        disable_screenshots
+      end
+
+      it "saves the session_state" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        expect { sync_click_session.run }.
+          to change { ClickSession::SessionState.count }.by(1)
+      end
+
+      it "returns a serialized FAIL response" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        response = sync_click_session.run
+
+        expect(response[:id]).to be_a(Integer)
+        expect(response[:status][:success]).to be(false)
+        expect(response[:data]).to be_nil
+      end
+
+      it "changes the state of the click_session to 'reported'" do
+        sync_click_session = ClickSession::Sync.new(model)
+
+        sync_click_session.run
+
+        # Expectation in the 'before do ...'
+      end
+    end
+  end
+
+  def mock_configuration_processor_class_with(processor_stub)
+    processor_double = class_double(ClickSession::WebRunner)
+    allow(processor_double).
+      to receive(:new).
+      and_return(processor_stub)
+
+    allow(ClickSession.configuration).
+      to receive(:processor_class).
+      and_return(processor_double)
+  end
+
+  def mock_configuration_notifier_class_with(notifier_mock)
+    notifier_double = class_double(ClickSession::Notifier)
+    allow(notifier_double).
+      to receive(:new).
+      and_return(notifier_mock)
+
+    allow(ClickSession.configuration).
+      to receive(:processor_class).
+      and_return(notifier_double)
+
+    notifier_mock
+  end
+
+  def disable_screenshots
+    allow(ClickSession.configuration).
+      to receive(:screenshot_enabled?).
+      and_return(false)
+  end
+
+
+  def stub_web_runner_processor_with(processor_stub)
+    web_runner_processor_stub = ClickSession::WebRunnerProcessor.new(processor_stub)
+
+    allow(web_runner_processor_stub).
+      to receive(:process).
+      with(model).
+      and_return(model)
+
+    allow(ClickSession::WebRunnerProcessor).
+      to receive(:new).
+      and_return(web_runner_processor_stub)
+
+    web_runner_processor_stub
+  end
+
+  def mock_click_session_processor_with(processor_stub, notifier_stub)
+    click_session_processor_mock = ClickSession::ClickSessionProcessor.new(
+      ClickSession::SessionState.new,
+      processor_stub,
+      notifier_stub
+    )
+
+    allow(click_session_processor_mock).
+      to receive(:process)
+
+    allow(ClickSession::ClickSessionProcessor).
+      to receive(:new).
+      and_return(click_session_processor_mock)
+  end
+
+  def mock_click_session_processor_and_raise_error(processor_stub, notifier_stub)
+    click_session_processor_mock = ClickSession::ClickSessionProcessor.new(
+      ClickSession::SessionState.new,
+      processor_stub,
+      notifier_stub
+    )
+
+    allow(click_session_processor_mock).
+      to receive(:process).
+      and_raise(ClickSession::TooManyRetriesError)
+
+    allow(ClickSession::ClickSessionProcessor).
+      to receive(:new).
+      and_return(click_session_processor_mock)
+  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_failed)
+
+    allow(notifier_stub).
+      to receive(:session_successful)
+
+    allow(notifier_stub).
+      to receive(:rescued_error)
+
+    # 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
+end