ama_layout 5.12.0 → 6.3.0.pre

data/lib/ama_layout/notifications.rb

@@ -1,73 +0,0 @@
-module AmaLayout
-  # Usage:
-  #
-  # class MyClass
-  #   include AmaLayout::Notifications
-  #
-  #   notification_store AmaLayout::Notifications::RedisStore.new(options)
-  #   notification_foreign_key :a_method_name_or_proc # defaults to :id
-  #
-  #   ...
-  # end
-  #
-  module Notifications
-    InvalidNotificationStore = Class.new(StandardError)
-
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.include(InstanceMethods)
-    end
-
-    module InstanceMethods
-      def notifications
-        @notifications ||= NotificationSet.new(_store, _foreign_key)
-      end
-
-      def notifications=(other)
-        @notifications = other
-      end
-
-      private
-
-      def _store
-        self.class._notification_store || invalid_store!
-      end
-
-      def _foreign_key
-        self.class._notification_foreign_key.call(self)
-      end
-
-      def invalid_store!
-        raise InvalidNotificationStore, 'a notification store must be specified'
-      end
-    end
-
-    module ClassMethods
-      def notification_store(store)
-        self._notification_store = store
-      end
-
-      def notification_foreign_key(key)
-        self._notification_foreign_key = key
-      end
-
-      def _notification_foreign_key
-        @_notification_foreign_key || Proc.new(&:id)
-      end
-
-      def _notification_store
-        @_notification_store
-      end
-
-      private
-
-      def _notification_store=(store)
-        @_notification_store = store
-      end
-
-      def _notification_foreign_key=(key)
-        @_notification_foreign_key = key.to_proc
-      end
-    end
-  end
-end

data/lib/ama_layout/notifications/abstract_store.rb

@@ -1,17 +0,0 @@
-module AmaLayout
-  module Notifications
-    class AbstractStore
-      def get(key, opts = {})
-        raise NotImplementedError, 'you must define a #get method in a subclass'
-      end
-
-      def set(key, value, opts = {})
-        raise NotImplementedError, 'you must define a #set method in a subclass'
-      end
-
-      def delete(key, opts = {})
-        raise NotImplementedError, 'you must define a #delete method in a subclass'
-      end
-    end
-  end
-end

data/lib/ama_layout/notifications/redis_store.rb

@@ -1,38 +0,0 @@
-module AmaLayout
-  module Notifications
-    class RedisStore < AbstractStore
-      delegate :clear, to: :base
-
-      attr_accessor :base
-
-      def initialize(opts = {})
-        self.base = ActiveSupport::Cache.lookup_store(
-          :redis_store,
-          opts.merge(raw: true)
-        )
-      end
-
-      def get(key, opts = {})
-        if opts.fetch(:default, false)
-          base.fetch(key) { opts[:default] }
-        else
-          base.read(key)
-        end
-      end
-
-      def set(key, value, opts = {})
-        base.write(key, value, opts) == 'OK'
-      end
-
-      def delete(key, opts = {})
-        base.delete(key, opts) == 1
-      end
-
-      def transaction
-        base.data.multi do
-          yield self
-        end
-      end
-    end
-  end
-end

data/spec/ama_layout/controllers/ama_layout/api/v1/notifications_controller_spec.rb

@@ -1,13 +0,0 @@
-describe AmaLayout::Api::V1::NotificationsController, type: :controller do
-  describe 'DELETE api/v1/notifications' do
-    routes { AmaLayout::Engine.routes }
-
-    before(:each) do
-      delete :dismiss_all
-    end
-
-    it 'returns a 204 No Content status' do
-      expect(response).to have_http_status(:no_content)
-    end
-  end
-end

data/spec/ama_layout/decorators/notification_decorator_spec.rb

@@ -1,57 +0,0 @@
-describe AmaLayout::NotificationDecorator do
-  let(:notification) do
-    AmaLayout::Notification.new(
-      header: 'test',
-      content: 'content',
-      type: :warning,
-      created_at: Date.yesterday.beginning_of_day,
-      active: true
-    )
-  end
-  subject { described_class.new(notification) }
-
-  describe '#created_at' do
-    around(:each) do |example|
-      Timecop.freeze(Time.zone.local(2017, 8)) do
-        example.run
-      end
-    end
-
-    it 'returns the time elapsed in english words' do
-      expect(subject.created_at).to eq('1 day ago')
-    end
-  end
-
-  describe '#icon' do
-    it 'returns a div' do
-      expect(subject.icon).to include('<div')
-    end
-
-    it 'contains the proper icon class' do
-      expect(subject.icon).to include('fa-exclamation')
-    end
-
-    it 'contains the proper colour class' do
-      expect(subject.icon).to include('right-sidebar__content-icon--orange')
-    end
-  end
-
-  describe '#active_class' do
-    context 'when active' do
-      it 'returns the proper class' do
-        expect(subject.active_class).to_not include('inactive')
-        expect(subject.active_class).to include('active')
-      end
-    end
-
-    context 'when inactive' do
-      before(:each) do
-        notification.dismiss!
-      end
-
-      it 'returns the proper class' do
-        expect(subject.active_class).to include('inactive')
-      end
-    end
-  end
-end

data/spec/ama_layout/navigation_helper_spec.rb

@@ -1,63 +0,0 @@
-describe AmaLayout::NavigationHelper do
-  subject { FactoryGirl.create(:user) }
-
-  describe '#navigation' do
-    before(:each) do
-      subject.class.include(AmaLayout::NavigationHelper).new
-    end
-
-    context 'non-member' do
-      subject { FactoryGirl.create(:user, :non_member) }
-
-      it 'shows non-member sidebar menu' do
-        expect(subject.navigation).to eq 'non-member'
-      end
-    end
-
-    context 'member' do
-      it 'shows member sidebar menu' do
-        expect(subject.navigation).to eq 'member'
-      end
-    end
-
-    context 'member with accr' do
-      subject { FactoryGirl.create(:user, :with_accr) }
-
-      it 'shows member sidebar menu' do
-        expect(subject.navigation).to eq 'member'
-      end
-    end
-
-    context 'member with mpp' do
-      subject { FactoryGirl.create(:user, :with_mpp) }
-
-      it 'shows member sidebar menu' do
-        expect(subject.navigation).to eq 'member'
-      end
-    end
-
-    context 'member in-renewal' do
-      subject { FactoryGirl.create(:user, :in_renewal) }
-
-      it 'shows in-renewal sidebar menu' do
-        expect(subject.navigation).to eq 'member-in-renewal'
-      end
-    end
-
-    context 'member in-renewal late' do
-      subject { FactoryGirl.create(:user, :in_renewal_late) }
-
-      it 'shows in-renewal-late sidebar menu' do
-        expect(subject.navigation).to eq 'member-in-renewal-late'
-      end
-    end
-
-    context 'member with outstanding balance' do
-      subject { FactoryGirl.create(:user, :outstanding_balance) }
-
-      it 'shows member-with-outstanding-balance sidebar menu' do
-        expect(subject.navigation).to eq 'member-with-outstanding-balance'
-      end
-    end
-  end
-end

data/spec/ama_layout/notification_scrubber_spec.rb

@@ -1,10 +0,0 @@
-describe AmaLayout::NotificationScrubber do
-  describe '#initialize' do
-    let(:sanitized) { Loofah.fragment(string).scrub!(subject).to_s }
-    let(:string) { '<script>alert("haxxed");</script><a href="#" invalid="test">test</a>waffles' }
-
-    it 'scrubs HTML tags from a string' do
-      expect(sanitized).to eq('alert("haxxed");<a href="#">test</a>waffles')
-    end
-  end
-end

data/spec/ama_layout/notification_set_spec.rb

@@ -1,281 +0,0 @@
-describe AmaLayout::NotificationSet do
-  let(:store) do
-    AmaLayout::Notifications::RedisStore.new(
-      db: 4,
-      namespace: 'test_notifications',
-      host: 'localhost'
-    )
-  end
-  let(:key) { 1 }
-  let(:duration) { AmaLayout::Notification::DEFAULT_LIFESPAN }
-  let(:store_key) { key.to_s }
-  let(:digest) { base_notification.digest }
-  let(:base_notification) do
-    AmaLayout::Notification.new(
-      type: :notice,
-      header: 'test',
-      content: 'test',
-      lifespan: duration,
-      version: '1.0.0',
-      created_at: Time.zone.local(2017, 06, 19),
-      active: true
-    )
-  end
-  let(:json) do
-    <<-JSON
-    {
-      "#{digest}": {
-        "type": "notice",
-        "header": "test",
-        "content": "test",
-        "created_at": "2017-06-19T06:00:00.000Z",
-        "active": true,
-        "lifespan": #{duration},
-        "version": "1.0.0"
-      }
-    }
-    JSON
-  end
-  let(:stale_json) do
-    <<-JSON
-    {
-      "d3c2bc71904100674325791b371db7446097f956ea76a304e787abd5f2588665": {
-        "type": "notice",
-        "header": "stale",
-        "content": "stale",
-        "created_at": "2012-06-19T06:00:00.000Z",
-        "active": true,
-        "lifespan": #{duration},
-        "version": "1.0.0"
-      }
-    }
-    JSON
-  end
-
-  subject { described_class.new(store, key) }
-
-  around(:each) do |example|
-    Timecop.freeze(Time.zone.local(2017, 6, 19)) do
-      store.clear
-      example.run
-      store.clear
-    end
-  end
-
-  describe '#initialize' do
-    context 'with valid JSON in data store' do
-      before(:each) do
-        store.set(store_key, notification)
-      end
-
-      context 'without stale notifications in the data store' do
-        let(:notification) { json }
-
-        it 'fetches the notifications' do
-          expect(subject.size).to eq(1)
-        end
-      end
-
-      context 'with stale notifications in the data store' do
-        let(:notification) { stale_json }
-
-        it 'returns an empty set' do
-          expect(subject).to be_empty
-        end
-
-        it 'cleans out stale notifications from the data store' do
-          subject
-          expect(store.get(store_key)).to eq('{}')
-        end
-      end
-    end
-
-    context 'with invalid JSON in data store' do
-      before(:each) do
-        store.set(store_key, '{"invalid_json":')
-      end
-
-      it 'logs to Rails logger' do
-        expect(Rails.logger).to receive(:error).with(instance_of(String))
-        subject
-      end
-
-      it 'deletes the key in data store' do
-        subject
-        expect(store.get(store_key)).to be nil
-      end
-
-      it 'returns an empty set' do
-        expect(subject).to be_empty
-      end
-
-      it 'sets the base attribute to a hash' do
-        expect(subject.base).to be_a(Hash)
-      end
-    end
-
-    context 'with no entry in data store' do
-      it 'returns an empty set' do
-        expect(subject).to be_empty
-      end
-    end
-  end
-
-  describe '#create' do
-    it 'returns the NotificationSet instance' do
-      expect(subject.create(header: 'test', content: 'test')).to be_a(described_class)
-    end
-
-    it 'creates a new active notification' do
-      subject.create(header: 'test', content: 'test')
-      expect(subject.size).to eq(1)
-    end
-
-    it 'saves a notification in data store' do
-      subject.create(header: 'test', content: 'test')
-      expect(store.get(store_key)).to be_a(String)
-    end
-
-    context 'when the same notification exists but is dismissed' do
-      before(:each) do
-        store.set(store_key, json)
-        subject.first.dismiss!
-        subject.save
-        subject.create(header: 'test', content: 'test')
-      end
-
-      it 'does not overwrite the notification' do
-        expect(subject.active).to be_empty
-      end
-
-      it 'still has the dismissed notification in the data store' do
-        data = JSON.parse(store.get(store_key))
-        notification = data.values.first
-        expect(data.values.first['active']).to be false
-      end
-    end
-  end
-
-  describe '#delete' do
-    before(:each) do
-      subject.create(base_notification.to_h)
-    end
-
-    context 'with an array as an argument' do
-      it 'deletes the notification from the data store' do
-        data = subject.delete([digest])
-        expect(data).to be_a(described_class)
-        expect(data).to be_empty
-        expect(store.get(store_key)).to eq('{}')
-      end
-
-      it 'returns falsey if nothing is deleted' do
-        expect(subject.delete(['missing'])).to be_falsey
-      end
-    end
-
-    context 'with string arguments' do
-      it 'deletes the notification from the data store' do
-        data = subject.delete(digest)
-        expect(data).to be_a(described_class)
-        expect(data).to be_empty
-        expect(store.get(store_key)).to eq('{}')
-      end
-
-      it 'returns falsey if nothing is deleted' do
-        expect(subject.delete('missing')).to be_falsey
-      end
-    end
-  end
-
-  describe '#destroy' do
-    context 'when data is removed' do
-      before(:each) do
-        subject.create(header: 'test', content: 'test', lifespan: 1.day)
-      end
-
-      it 'returns a NotificationSet instance' do
-        expect(subject.destroy!).to be_a(described_class)
-      end
-
-      it 'removes the notifications from the data store' do
-        subject.destroy!
-        expect(store.get(store_key)).to be nil
-      end
-
-      it 'returns an empty set' do
-        expect(subject.destroy!).to be_empty
-      end
-    end
-
-    context 'when data is not removed' do
-      it 'returns false' do
-        expect(subject.destroy!).to be false
-      end
-    end
-  end
-
-  describe '#find' do
-    context 'when id is not preset' do
-      it 'returns nil' do
-        expect(subject.find('invalid')).to be nil
-      end
-    end
-
-    context 'when id is present' do
-      let(:id) { subject.last.id }
-
-      before(:each) do
-        subject.create(header: 'test', content: 'test')
-      end
-
-      it 'returns the notification' do
-        expect(subject.find(id)).to eq(subject.last)
-      end
-    end
-  end
-
-  describe '#save' do
-    before(:each) do
-      subject.create(header: 'test', content: 'test')
-    end
-
-    it 'saves the notifications' do
-      expect(subject.last.active?).to be true
-      subject.last.dismiss!
-      subject.save
-      expect(subject.active).to be_empty
-    end
-
-    it 'returns the NotificationSet instance' do
-      expect(subject.save).to be_a(described_class)
-    end
-  end
-
-  describe '#inspect' do
-    it 'returns a stringified instance' do
-      expect(subject.inspect).to eq('<AmaLayout::NotificationSet>: []')
-    end
-  end
-
-  context 'scoping' do
-    before(:each) do
-      subject.create(header: 'test', content: 'test')
-      subject.create(header: 'inactive', content: 'inactive')
-      subject.last.dismiss!
-      subject.save
-    end
-
-    describe '#all' do
-      it 'returns both active and inactive notifications' do
-        expect(subject.all.size).to eq(2)
-      end
-    end
-
-    describe '#active' do
-      it 'returns only active notifications' do
-        expect(subject.active.size).to eq(1)
-      end
-    end
-  end
-end