# Copyright (C) 2012-2021 Zammad Foundation, http://zammad-foundation.org/

require 'rails_helper'

# NOTE: This class uses custom .add & .remove methods
# to create and destroy records.
# This pattern is a strong candidate for refactoring
# to make use of Rails' native ActiveRecord + callbacks functionality.
RSpec.describe Store, type: :model do
  subject(:store) { described_class.add(**attributes) }

  let(:attributes) do
    {
      object:        'Test',
      o_id:          1,
      data:          data,
      filename:      filename,
      preferences:   preferences,
      created_by_id: 1,
    }
  end

  let(:data) { 'hello world' }
  let(:filename) { 'test.txt' }
  let(:preferences) { {} }

  describe 'Class methods:' do
    describe '.add' do
      it 'creates a new Store record' do
        expect { described_class.add(**attributes) }.to change(described_class, :count).by(1)
      end

      it 'returns the newly created Store record' do
        expect(described_class.add(**attributes)).to eq(described_class.last)
      end

      it 'saves data to #content attribute' do
        expect { described_class.add(**attributes) }
          .to change { described_class.last&.content }.to('hello world')
      end

      it 'saves filename to #filename attribute' do
        expect { described_class.add(**attributes) }
          .to change { described_class.last&.filename }.to('test.txt')
      end

      it 'sets #provider attribute to "DB"' do
        expect { described_class.add(**attributes) }
          .to change { described_class.last&.provider }.to('DB')
      end

      context 'with UTF-8 (non-ASCII) characters in text' do
        let(:data) { 'hello world äöüß' }

        it 'stores data as binary string to #content attribute' do
          expect { described_class.add(**attributes) }
            .to change { described_class.last&.content }.to('hello world äöüß'.force_encoding('ASCII-8BIT'))
        end
      end

      context 'with UTF-8 (non-ASCII) characters in filename' do
        let(:filename) { 'testäöüß.txt' }

        it 'stores filename verbatim to #filename attribute' do
          expect { described_class.add(**attributes) }
            .to change { described_class.last&.filename }.to('testäöüß.txt')
        end
      end

      context 'with binary data' do
        let(:data) { File.binread(Rails.root.join('test/data/pdf/test1.pdf')) }

        it 'stores data as binary string to #content attribute' do
          expect { described_class.add(**attributes) }
            .to change { described_class.last&.content&.class }.to(String)
            .and change { described_class.last&.content }.to(data)
        end

        it 'saves filename to #filename attribute' do
          expect { described_class.add(**attributes) }
            .to change { described_class.last&.filename }.to('test.txt')
        end

        it 'sets #provider attribute to "DB"' do
          expect { described_class.add(**attributes) }
            .to change { described_class.last&.provider }.to('DB')
        end

        context 'when an identical file has been stored before under a different name' do
          before { described_class.add(**attributes) }

          it 'creates a new (duplicate) described_class record' do
            expect { described_class.add(**attributes.merge(filename: 'test-again.pdf')) }
              .to change(described_class, :count).by(1)
              .and change { described_class.last&.filename }.to('test-again.pdf')
              .and not_change { described_class.last&.content&.class }
              .and not_change { described_class.last&.content }
          end
        end
      end

      context 'with an image (jpeg/jpg/png)' do
        let(:data) { File.binread(Rails.root.join('test/data/upload/upload2.jpg')) }
        let(:preferences) { { content_type: 'image/jpg' } }

        it 'generates previews' do
          described_class.add(**attributes)

          expect(described_class.last.preferences)
            .to include(resizable: true, content_inline: true, content_preview: true)
        end

        context 'when system is in import mode' do
          before { Setting.set('import_mode', true) }

          it 'does not generate previews' do
            described_class.add(**attributes)

            expect(described_class.last.preferences)
              .not_to include(resizable: true, content_inline: true, content_preview: true)
          end
        end
      end
    end

    describe '.remove' do
      before { described_class.add(**attributes) }

      it 'destroys the specified Store record' do
        expect { described_class.remove(object: 'Test', o_id: 1) }
          .to change(described_class, :count).by(-1)
      end

      it 'destroys the associated Store::File record' do
        expect { described_class.remove(object: 'Test', o_id: 1) }
          .to change { described_class::File.count }.by(-1)
      end

      context 'with the same file stored under multiple o_ids' do
        before { described_class.add(**attributes.merge(o_id: 2)) }

        it 'destroys only the specified Store record' do
          expect { described_class.remove(object: 'Test', o_id: 1) }
            .to change(described_class, :count).by(-1)
        end

        it 'does not destroy the associated Store::File record (because it is referenced by another Store)' do
          expect { described_class.remove(object: 'Test', o_id: 1) }
            .not_to change { Store::File.count }
        end
      end

      context 'with multiple files stored under the same o_id' do
        before { described_class.add(**attributes.merge(data: 'bar')) }

        it 'destroys all matching Store records' do
          expect { described_class.remove(object: 'Test', o_id: 1) }
            .to change(described_class, :count).by(-2)
        end

        it 'destroys all associated Store::File records' do
          expect { described_class.remove(object: 'Test', o_id: 1) }
            .to change { Store::File.count }.by(-2)
        end
      end
    end

    describe '.list' do
      let!(:store) do
        described_class.add(
          object:        'Test',
          o_id:          1,
          data:          'hello world',
          filename:      'test.txt',
          preferences:   {},
          created_by_id: 1,
        )
      end

      it 'runs a Store.where query for :object / :o_id parameters (:object is Store::Object association name)' do
        expect(described_class.list(object: 'Test', o_id: 1))
          .to eq([store])
      end

      context 'without a Store::Object name' do
        it 'returns an empty ActiveRecord::Relation' do
          expect(described_class.list(o_id: 1))
            .to be_an(ActiveRecord::Relation).and be_empty
        end
      end

      context 'without a #o_id' do
        it 'returns an empty ActiveRecord::Relation' do
          expect(described_class.list(object: 'Test'))
            .to be_an(ActiveRecord::Relation).and be_empty
        end
      end
    end
  end

  describe 'Instance methods:' do
    describe 'image previews (#content_inline / #content_preview)' do
      let(:attributes) do
        {
          object:        'Test',
          o_id:          1,
          data:          data,
          filename:      'test1.pdf',
          preferences:   {
            content_type: content_type,
            content_id:   234,
          },
          created_by_id: 1,
        }
      end

      let(:resized_inline_image) do
        File.binwrite(temp_file, store.content_inline)
        Rszr::Image.load(temp_file)
      end

      let(:resized_preview_image) do
        File.binwrite(temp_file.next, store.content_preview)
        Rszr::Image.load(temp_file.next)
      end

      let(:temp_file) { Tempfile.new.path }

      context 'with content_type: "text/plain"' do
        let(:content_type) { 'text/plain' }

        context 'and text content' do
          let(:data) { 'foo' }

          it 'cannot be resized (neither inlined nor previewed)' do
            expect { store.content_inline }
              .to raise_error('Unable to generate inline')

            expect { store.content_preview }
              .to raise_error('Unable to generate preview')

            expect(store.preferences)
              .to not_include(resizable: true)
              .and not_include(content_inline: true)
              .and not_include(content_preview: true)
          end
        end
      end

      context 'with content_type: "image/*"' do
        context 'and text content' do
          let(:content_type) { 'image/jpeg' }
          let(:data) { 'foo' }

          it 'cannot be resized (neither inlined nor previewed)' do
            expect { store.content_inline }
              .to raise_error('Unable to generate inline')

            expect { store.content_preview }
              .to raise_error('Unable to generate preview')

            expect(store.preferences)
              .to not_include(resizable: true)
              .and not_include(content_inline: true)
              .and not_include(content_preview: true)
          end
        end

        context 'with image content (width > 1800px)' do
          context 'width <= 200px' do
            let(:content_type) { 'image/png' }
            let(:data) { File.binread(Rails.root.join('test/data/image/1x1.png')) }

            it 'cannot be resized (neither inlined nor previewed)' do
              expect { store.content_inline }
                .to raise_error('Unable to generate inline')

              expect { store.content_preview }
                .to raise_error('Unable to generate preview')

              expect(store.preferences)
                .to not_include(resizable: true)
                .and not_include(content_inline: true)
                .and not_include(content_preview: true)
            end
          end

          context '200px < width <= 1800px)' do
            let(:content_type) { 'image/png' }
            let(:data) { File.binread(Rails.root.join('test/data/image/1000x1000.png')) }

            it 'can be resized (previewed but not inlined)' do
              expect { store.content_inline }
                .to raise_error('Unable to generate inline')

              expect(resized_preview_image.width).to eq(200)

              expect(store.preferences)
                .to include(resizable: true)
                .and not_include(content_inline: true)
                .and include(content_preview: true)
            end
          end

          context '1800px < width' do
            let(:content_type) { 'image/jpeg' }
            let(:data) { File.binread(Rails.root.join('test/data/upload/upload2.jpg')) }

            it 'can be resized (inlined @ 1800px wide or previewed @ 200px wide)' do
              expect(resized_inline_image.width).to eq(1800)
              expect(resized_preview_image.width).to eq(200)

              expect(store.preferences)
                .to include(resizable: true)
                .and include(content_inline: true)
                .and include(content_preview: true)
            end

            context 'kind of wide/short: 8000x300' do
              let(:data) { File.binread(Rails.root.join('test/data/image/8000x300.jpg')) }

              it 'can be resized (inlined @ 1800px wide or previewed @ 200px wide)' do
                expect(resized_inline_image.width).to eq(1800)
                expect(resized_preview_image.width).to eq(200)

                expect(store.preferences)
                  .to include(resizable: true)
                  .and include(content_inline: true)
                  .and include(content_preview: true)
              end
            end

            context 'very wide/short: 4000x1; i.e., <= 6px vertically per 200px (preview) or 1800px (inline) horizontally' do
              let(:data) { File.binread(Rails.root.join('test/data/image/4000x1.jpg')) }

              it 'cannot be resized (neither inlined nor previewed)' do
                expect { store.content_inline }
                  .to raise_error('Unable to generate inline')

                expect { store.content_preview }
                  .to raise_error('Unable to generate preview')

                expect(store.preferences)
                  .to not_include(resizable: true)
                  .and not_include(content_inline: true)
                  .and not_include(content_preview: true)
              end
            end

            context 'very wide/short: 8000x25; i.e., <= 6px vertically per 200px (preview) or 1800px (inline) horizontally' do
              let(:data) { File.binread(Rails.root.join('test/data/image/8000x25.jpg')) }

              it 'cannot be resized (neither inlined nor previewed)' do
                expect { store.content_inline }
                  .to raise_error('Unable to generate inline')

                expect { store.content_preview }
                  .to raise_error('Unable to generate preview')

                expect(store.preferences)
                  .to not_include(resizable: true)
                  .and not_include(content_inline: true)
                  .and not_include(content_preview: true)
              end
            end
          end
        end
      end
    end
  end

  context 'when preferences exceed storage size' do

    let(:valid_entries) do
      {
        content_type: 'text/plain',
        content_id:   234,
      }
    end

    shared_examples 'keeps other entries' do

      context 'when other entries are present' do

        let(:preferences) do
          super().merge(valid_entries)
        end

        it 'keeps these entries' do
          expect(store.preferences).to include(valid_entries)
        end
      end
    end

    context 'when single content is oversized' do

      let(:preferences) do
        {
          oversized_content: '0' * 2500,
        }
      end

      it 'removes that entry' do
        expect(store.preferences).not_to have_key(:oversized_content)
      end

      include_examples 'keeps other entries'
    end

    context 'when the sum of multiple contents is oversized' do

      let(:preferences) do
        {
          oversized_content1: '0' * 2000,
          oversized_content2: '0' * 2000,
        }
      end

      it 'removes first entry' do
        expect(store.preferences).not_to have_key(:oversized_content1)
      end

      it 'keeps second entry' do
        expect(store.preferences).to have_key(:oversized_content2)
      end

      include_examples 'keeps other entries'
    end

    context 'when single key is oversized' do

      let(:oversized_key) { '0' * 2500 }
      let(:preferences) do
        {
          oversized_key => 'valid content',
        }
      end

      it 'removes that entry' do
        expect(store.preferences).not_to have_key(oversized_key)
      end

      include_examples 'keeps other entries'
    end

    context 'when the sum of multiple keys is oversized' do

      let(:oversized_key1) { '0' * 1500 }
      let(:oversized_key2) { '1' * 1500 }
      let(:preferences) do
        {
          oversized_key1 => 'valid content',
          oversized_key2 => 'valid content',
        }
      end

      it 'removes first entry' do
        expect(store.preferences).not_to have_key(oversized_key1)
      end

      it 'keeps second entry' do
        expect(store.preferences).to have_key(oversized_key2)
      end

      include_examples 'keeps other entries'
    end
  end
end