require 'sbuilder'

RSpec.shared_examples_for "snippet_loader_plugin: signature" do

  describe "Interface of Snippet Loader Plugin" do

    describe "should be configurable" do    
      
      it ".configure class method responded to in class" do
        expect( plugin.class ).to respond_to( :configure )
      end

      it "must implement '.configure' singleton method" do
        expect( plugin.class.singleton_methods(false).include?(:configure) ).to eql( true )
      end

    end
    

    describe "API provided by 'SnippetLoaderPlugin' parent class" do

      it "#logger" do
        expect( plugin ).to respond_to( :logger )
      end

      it "#snippetFacade" do
        expect( plugin ).to respond_to( :snippetFacade )
      end


      it "#registerMetatype" do
        expect( plugin ).to respond_to( :registerMetatype )
      end


      it "#validateProperties" do
        expect( plugin ).to respond_to( :validateProperties )
      end

      it ".validateProperties (class method)" do
        # configure -method defined on loader class?
        expect( plugin.class.instance_methods ).to include( :validateProperties )
      end
      

      it "#oneOf" do
        expect( plugin ).to respond_to( :oneOf )
      end
      
      
    end

    describe "implement API loading snippets" do
      

      it "#doRegisterSnippets" do
        expect( plugin.class.instance_methods(false).include?( :doRegisterSnippets )).to eql( true )
      end
      
    end


  end  # interfaces

end

# ------------------------------------------------------------------

RSpec.shared_examples_for "snippet_loader_plugin: registers metatypes" do

  # input let ( :plugin )
  
  describe "in registerMetatype" do

    let ( :facade ) { notifier = instance_double( Sbuilder::SnippetLoaderFacade) }
    let ( :metatype ) { double("metatype")}
    let ( :desc ) { double("metatype description")}    

    it "#calls facade" do
      expect( facade ).to receive( :registerMetatype ).with( metatype, desc )
      plugin.registerMetatype( metatype, desc )
    end

  end
  
end

RSpec.shared_examples_for "snippet_loader_plugin: registers snippets" do

  describe "in method doRegisterSnippets" do

    let ( :facade ) { notifier = instance_double( Sbuilder::SnippetLoaderFacade) }

    # subroutine to prepare plugin for tests
    def preprarePlugin( plugin, snippetDefitions )
      allow( plugin ).to receive( :snippetFacade ).and_return( facade )      
      expect( facade ).to receive( :handOver ).exactly( snippetDefitions.nil? ? 0 : snippetDefitions.length ).times
    end
    
    it "#handOver called for each entry in 'snippetDefitions'" do
      preprarePlugin( plugin, snippetDefitions )
      # call method using an array
      plugin.doRegisterSnippets( snippetDefitions )
    end

    it "#registerSnippets passes 'snippetsDefs' to #doregisterSnippets" do
      snippetDefitions = double( "snippetDefitions" )
      expect(  plugin ).to receive( :doRegisterSnippets ).with( snippetDefitions )
      plugin.registerSnippets( snippetDefitions )
    end
    
  end

end


RSpec.shared_examples_for "snippet_loader_facade: signature" do

  describe "Interface of 'SnippetLoaderFacade'" do

    describe "Provides api to register metatypes" do
      
      it "#registerMetatype" do
        expect( facade ).to respond_to( :registerMetatype )
      end

      it "#baseMetatypes" do
        expect( facade ).to respond_to( :baseMetatypes )
      end
      
      
      
    end
    

    describe "Provides api for snippet loader to hand over snippets" do

      it "#handOver" do
        expect( facade ).to respond_to( :handOver )
      end

    end

    describe "Provides api for controller to accept snippets hander over" do

      it "#setSnippetHeader" do
        expect( facade ).to respond_to( :setSnippetHeader )
      end

      it "#setSnippetFooter" do
        expect( facade ).to respond_to( :setSnippetFooter )
      end

      it "#acceptSnippets" do
        expect( facade ).to respond_to( :acceptSnippets )
      end

    end

    describe "Miscellaneous services" do

      it "#getCacheDir" do
        expect( facade ).to respond_to( :getCacheDir )
      end

      it "#createLogger" do
        expect( facade ).to respond_to( :createLogger )
      end

      it "#version" do
        expect( facade ).to respond_to( :version )
      end

    end

  end  # interfaces

end

RSpec.shared_examples_for "snippet_loader_facade: services" do

  describe "Miscellaneous services" do 

    describe "version'" do

      # ------------------------------------------------------------------
      # version
      
      it "#return Sbuilder version" do
        expect( facade.version ).to eql( Sbuilder::version )
      end
      
    end # version

    # ------------------------------------------------------------------
    # createLogger
    describe "createLogger" do

      describe "returns object'" do

        let ( :logger ) { facade.createLogger(nil) }

        it "#responds to :error" do
          expect( logger ).to respond_to( :error )
        end
        
        it "#responds to :debug" do
          expect( logger ).to respond_to( :debug )
        end
        
        it "#responds to :info" do
          expect( logger ).to respond_to( :info )
        end
        
        it "#responds to :info" do
          expect( logger ).to respond_to( :debug? )
        end
        
      end
      
    end # version

  end # Miscellaneous services

  
  
end