# encoding: utf-8
require 'spec_helper'
require 'fedux_org_stdlib/models/filesystem_based_model'

RSpec.describe Models::FilesystemBasedModel do
  before(:each) do
    @model = Class.new(Models::BaseModel) do
      include Models::FilesystemBasedModel

      def self.load_from_filesystem
        [:hello, :world].each { |s| create(s) }
      end
    end

    @model.clear

    # where a name for a class is relevant
    module Test123
      module Models
        class TestClassForFilesystem < FeduxOrgStdlib::Models::BaseModel
          include FeduxOrgStdlib::Models::FilesystemBasedModel
        end
      end
    end
  end

  it 'finds all available filter' do
    @model.init
    filter = @model.find(:hello)
    expect(filter.name).to eq(:hello)
  end

  it 'is default that all found filters are disabled' do
    @model.init
    all_filter = @model.all
    all_not_enabled_filter = @model.find_all(enabled: false)
    expect(all_filter.size).to eq(all_not_enabled_filter.size)
  end

  it 'enables a filter by request' do
    @model.init
    @model.enable(:hello)
    all_enabled_filter = @model.find_all(enabled: true)
    filter = @model.find(:hello)

    expect(all_enabled_filter).to eq([filter])
  end

  it 's find method supports a hash based syntax' do
    @model.init
    @model.enable(:hello)

    enabled_filter = @model.find(name: :hello, enabled: true)
    expect(enabled_filter.name).to eq(:hello)
  end

  it 's find method supports a symbol based syntax as well. The search string is compared against the name method.' do
    @model.init
    enabled_filter = @model.find(:hello)
    expect(enabled_filter.name).to eq(:hello)

    enabled_filter = @model.find_all(:hello)
    expect(enabled_filter.first.name).to eq(:hello)
  end

  it 's find method supports a string based syntax as well. The search string is compared against the name method.' do
    @model.init
    enabled_filter = @model.find('hello')
    expect(enabled_filter.name).to eq(:hello)

    enabled_filter = @model.find_all('hello')
    expect(enabled_filter.first.name).to eq(:hello)
  end

  it 'raises an error if an unknown search criteria is used' do
    @model.init
    expect do
      @model.find(unknown: 'hello')
    end.to raise_error FeduxOrgStdlib::Models::Exceptions::InvalidSearchCriteria
  end

  it 'returns the module name' do
    expect(Test123::Models::TestClassForFilesystem.send(:module_name)).to eq('Test123::Models')
  end

  it 'returns the model name' do
    expect(Test123::Models::TestClassForFilesystem.send(:model_name)).to eq('TestClassForFilesystem')
  end

  context '#library_name' do
    it 'returns the library name' do
      expect(Test123::Models::TestClassForFilesystem.send(:library_name)).to eq('Test123')
    end
  end

  context '#path_to_instances' do
    klass = Class.new(FeduxOrgStdlib::Models::BaseModel) do
      include FeduxOrgStdlib::Models::FilesystemBasedModel

      def self.model_name
        'FindFiles'
      end

      def self.model_path
        File.join(examples_directory, 'models', 'filesystem_based', 'find_files')
      end

    end

    it 'returns the path to the instances' do
      expect(klass.send(:path_to_instances)).to eq(File.join(examples_directory, 'models', 'find_files'))
    end
  end

  context '#find_files' do
    klass = Class.new(FeduxOrgStdlib::Models::BaseModel) do
      include FeduxOrgStdlib::Models::FilesystemBasedModel

      def self.path_to_instances
        File.join(examples_directory, 'models', 'filesystem_based', 'find_files')
      end

      def self.suffix
        '.rb'
      end
    end

    it 'search for available instances in filesystem' do
      expect(klass.send(:find_files)).to eq(
        [
          File.join(examples_directory, 'models', 'filesystem_based', 'find_files', 'abc.rb'),
          File.join(examples_directory, 'models', 'filesystem_based', 'find_files', 'cde.rb')
        ]
     )
    end
  end

  context '#init' do
    it 'init should only add unknown instances' do
      @model.init
      count1 = @model.all.size
      @model.init
      count2 = @model.all.size
      expect(count2).to eq(count1)
    end
  end
end