algoliasearch-jekyll 0.2.2 → 0.2.3

data/spec/push_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+
+describe(AlgoliaSearchJekyllPush) do
+  let(:push) { AlgoliaSearchJekyllPush }
+  let(:site) { get_site }
+  let(:page_file) { site.file_by_name('about.md') }
+  let(:html_page_file) { site.file_by_name('authors.html') }
+  let(:excluded_page_file) { site.file_by_name('excluded.html') }
+  let(:post_file) { site.file_by_name('2015-07-02-test-post.md') }
+  let(:static_file) { site.file_by_name('ring.png') }
+  let(:document_file) { site.file_by_name('collection-item.md') }
+  let(:html_document_file) { site.file_by_name('collection-item.html') }
+  let(:options) do
+    {
+      'drafts' => true
+    }
+  end
+  let(:config) do
+    {
+      'source' => File.expand_path('./spec/fixtures'),
+      'markdown_ext' => 'md,mkd',
+      'algolia' => {
+        'application_id' => 'APPID',
+        'index_name' => 'INDEXNAME'
+      }
+    }
+  end
+
+  describe 'init_options' do
+    it 'sets options and config' do
+      # Given
+      args = nil
+
+      # When
+      push.init_options(args, options, config)
+
+      # Then
+      expect(push.options).to include(options)
+      expect(push.config).to include(config)
+    end
+
+    it 'sets indexname from the commandline' do
+      # Given
+      args = ['newindex']
+
+      # When
+      push.init_options(args, options, config)
+
+      # Then
+      expect(push.config['algolia']['index_name']).to eq 'newindex'
+    end
+  end
+
+  describe 'indexable?' do
+    before(:each) do
+      push.init_options(nil, options, config)
+    end
+
+    it 'exclude StaticFiles' do
+      expect(push.indexable?(static_file)).to eq false
+    end
+
+    it 'keeps markdown files' do
+      expect(push.indexable?(page_file)).to eq true
+    end
+
+    it 'keeps html files' do
+      expect(push.indexable?(html_page_file)).to eq true
+    end
+
+    it 'keeps markdown documents' do
+      expect(push.indexable?(document_file)).to eq true
+    end
+
+    it 'keeps html documents' do
+      expect(push.indexable?(html_document_file)).to eq true
+    end
+
+    it 'exclude file specified in config' do
+      # Given
+      config['algolia']['excluded_files'] = [
+        'excluded.html'
+      ]
+      push.init_options(nil, options, config)
+
+      # Then
+      expect(push.indexable?(excluded_page_file)).to eq false
+    end
+  end
+
+  describe 'api_key' do
+    it 'returns nil if no key found' do
+      # Given
+      push.init_options(nil, options, config)
+
+      # When
+      expect(push.api_key).to be_nil
+    end
+
+    it 'reads from ENV var if set' do
+      # Given
+      push.init_options(nil, options, config)
+      stub_const('ENV', 'ALGOLIA_API_KEY' => 'APIKEY_FROM_ENV')
+
+      # When
+      actual = push.api_key
+
+      # Then
+      expect(actual).to eq 'APIKEY_FROM_ENV'
+    end
+
+    it 'reads from _algolia_api_key in source if set' do
+      # Given
+      config['source'] = File.join(config['source'], 'api_key_dir')
+      push.init_options(nil, options, config)
+
+      # When
+      actual = push.api_key
+
+      # Then
+      expect(actual).to eq 'APIKEY_FROM_FILE'
+    end
+
+    it 'reads from ENV before from file' do
+      # Given
+      config['source'] = File.join(config['source'], 'api_key_dir')
+      stub_const('ENV', 'ALGOLIA_API_KEY' => 'APIKEY_FROM_ENV')
+      push.init_options(nil, options, config)
+
+      # When
+      actual = push.api_key
+
+      # Then
+      expect(actual).to eq 'APIKEY_FROM_ENV'
+    end
+  end
+
+  describe 'check_credentials' do
+    it 'should display error if no api key' do
+      # Given
+      config['algolia'] = {
+        'application_id' => 'APP_ID',
+        'index_name' => 'INDEX_NAME'
+      }
+      push.init_options(nil, options, config)
+
+      # Then
+      expect(Jekyll.logger).to receive(:error).with(/api key/i)
+      expect(Jekyll.logger).to receive(:warn).at_least(:once)
+      expect(-> { push.check_credentials }).to raise_error SystemExit
+    end
+
+    it 'should display error if no application id' do
+      # Given
+      config['algolia'] = {
+        'application_id' => nil,
+        'index_name' => 'INDEX_NAME'
+      }
+      stub_const('ENV', 'ALGOLIA_API_KEY' => 'APIKEY_FROM_ENV')
+      push.init_options(nil, options, config)
+
+      # Then
+      expect(Jekyll.logger).to receive(:error).with(/application id/i)
+      expect(Jekyll.logger).to receive(:warn).at_least(:once)
+      expect(-> { push.check_credentials }).to raise_error SystemExit
+    end
+
+    it 'should display error if no index name' do
+      # Given
+      config['algolia'] = {
+        'application_id' => 'APPLICATION_ID',
+        'index_name' => nil
+      }
+      stub_const('ENV', 'ALGOLIA_API_KEY' => 'APIKEY_FROM_ENV')
+      push.init_options(nil, options, config)
+
+      # Then
+      expect(Jekyll.logger).to receive(:error).with(/index name/i)
+      expect(Jekyll.logger).to receive(:warn).at_least(:once)
+      expect(-> { push.check_credentials }).to raise_error SystemExit
+    end
+  end
+
+  describe 'configure_index' do
+    it 'sets some sane defaults' do
+      # Given
+      push.init_options(nil, options, config)
+      index = double
+
+      # Then
+      expected = {
+        attributeForDistinct: 'title',
+        distinct: true,
+        customRanking: ['desc(posted_at)', 'desc(weight)']
+      }
+      expect(index).to receive(:set_settings).with(hash_including(expected))
+
+      # When
+      push.configure_index(index)
+    end
+
+    it 'allow user to override all settings' do
+      # Given
+      settings = {
+        distinct: false,
+        customSetting: 'foo',
+        customRanking: ['asc(foo)', 'desc(bar)']
+      }
+      config['algolia']['settings'] = settings
+      push.init_options(nil, options, config)
+      index = double
+
+      # Then
+      expect(index).to receive(:set_settings).with(hash_including(settings))
+
+      # When
+      push.configure_index(index)
+    end
+  end
+end

data/spec/record_extractor_spec.rb

@@ -0,0 +1,451 @@
+require 'spec_helper'
+
+describe(AlgoliaSearchRecordExtractor) do
+  let(:extractor) { AlgoliaSearchRecordExtractor }
+  let(:site) { get_site }
+  let(:page_file) { extractor.new(site.file_by_name('about.md')) }
+  let(:html_page_file) { extractor.new(site.file_by_name('authors.html')) }
+  let(:post_file) { extractor.new(site.file_by_name('test-post.md')) }
+  let(:hierarchy_page_file) { extractor.new(site.file_by_name('hierarchy.md')) }
+  let(:weight_page_file) { extractor.new(site.file_by_name('weight.md')) }
+  let(:document_file) { extractor.new(site.file_by_name('collection-item.md')) }
+
+  describe 'metadata' do
+    it 'gets metadata from page' do
+      # Given
+      actual = page_file.metadata
+
+      # Then
+      expect(actual[:type]).to eq 'page'
+      expect(actual[:slug]).to eq 'about'
+      expect(actual[:title]).to eq 'About page'
+      expect(actual[:url]).to eq '/about.html'
+      expect(actual[:custom]).to eq 'Foo'
+    end
+
+    it 'gets metadata from post' do
+      # Given
+      actual = post_file.metadata
+
+      # Then
+      expect(actual[:type]).to eq 'post'
+      expect(actual[:slug]).to eq 'test-post'
+      expect(actual[:title]).to eq 'Test post'
+      expect(actual[:url]).to eq '/2015/07/02/test-post.html'
+      expect(actual[:posted_at]).to eq 1_435_788_000
+      expect(actual[:custom]).to eq 'Foo'
+    end
+
+    it 'gets metadata from document' do
+      # Given
+      actual = document_file.metadata
+
+      # Then
+      expect(actual[:type]).to eq 'document'
+      expect(actual[:slug]).to eq 'collection-item'
+      expect(actual[:title]).to eq 'Collection Item'
+      expect(actual[:url]).to eq '/my-collection/collection-item.html'
+      expect(actual[:custom]).to eq 'Foo'
+    end
+  end
+
+  describe 'tags' do
+    it 'returns nil if no tag found' do
+      expect(page_file.tags).to eq nil
+    end
+    it 'extract tags from front matter' do
+      # Given
+      actual = post_file.tags
+
+      # Then
+      expect(actual).to include('tag', 'another tag')
+    end
+  end
+
+  describe 'html_nodes' do
+    it 'returns the list of all <p> by default' do
+      expect(page_file.html_nodes.size).to eq 6
+    end
+
+    it 'allow _config.yml to override the selector' do
+      # Given
+      site = get_site(algolia: { 'record_css_selector' => 'p,ul' })
+      page_file = extractor.new(site.file_by_name('about.md'))
+
+      expect(page_file.html_nodes.size).to eq 7
+    end
+  end
+
+  describe 'node_heading_parent' do
+    it 'returns the direct heading right above' do
+      # Given
+      nodes = hierarchy_page_file.html_nodes
+      p = nodes[0]
+
+      # When
+      actual = hierarchy_page_file.node_heading_parent(p)
+
+      # Then
+      expect(actual.name).to eq 'h1'
+      expect(actual.text).to eq 'H1'
+    end
+
+    it 'returns the closest heading even if in a sub tag' do
+      # Given
+      nodes = hierarchy_page_file.html_nodes
+      p = nodes[2]
+
+      # When
+      actual = hierarchy_page_file.node_heading_parent(p)
+
+      # Then
+      expect(actual.name).to eq 'h2'
+      expect(actual.text).to eq 'H2A'
+    end
+
+    it 'should automatically go up one level when indexing headings' do
+      # Given
+      site = get_site(algolia: { 'record_css_selector' => 'p,h2' })
+      hierarchy_page_file = extractor.new(site.file_by_name('hierarchy.md'))
+      nodes = hierarchy_page_file.html_nodes
+      h2 = nodes[4]
+
+      # When
+      actual = hierarchy_page_file.node_heading_parent(h2)
+
+      # Then
+      expect(actual.name).to eq 'h1'
+      expect(actual.text).to eq 'H1'
+    end
+
+    it 'should find the correct parent when indexing deep headings' do
+      # Given
+      site = get_site(algolia: { 'record_css_selector' => 'h2' })
+      hierarchy_page_file = extractor.new(site.file_by_name('hierarchy.md'))
+      nodes = hierarchy_page_file.html_nodes
+      h2 = nodes[2]
+
+      # When
+      actual = hierarchy_page_file.node_heading_parent(h2)
+
+      # Then
+      expect(actual.name).to eq 'h1'
+      expect(actual.text).to eq 'H1'
+    end
+  end
+
+  describe 'node_hierarchy' do
+    it 'returns the unique parent of a simple element' do
+      # Note: First <p> should only have a h1 as hierarchy
+      # Given
+      nodes = hierarchy_page_file.html_nodes
+      p = nodes[0]
+
+      # When
+      actual = hierarchy_page_file.node_hierarchy(p)
+
+      # Then
+      expect(actual).to include(h1: 'H1')
+    end
+
+    it 'returns the heading hierarchy of multiple headings' do
+      # Note: 5th <p> is inside h3, second h2 and main h1
+      # Given
+      nodes = hierarchy_page_file.html_nodes
+      p = nodes[4]
+
+      # When
+      actual = hierarchy_page_file.node_hierarchy(p)
+
+      # Then
+      expect(actual).to include(h1: 'H1', h2: 'H2B', h3: 'H3A')
+    end
+
+    it 'works even if heading not on the same level' do
+      # Note: The 6th <p> is inside a div
+      # Given
+      nodes = hierarchy_page_file.html_nodes
+      p = nodes[5]
+
+      # When
+      actual = hierarchy_page_file.node_hierarchy(p)
+
+      # Then
+      expect(actual).to include(h1: 'H1', h2: 'H2B', h3: 'H3A', h4: 'H4')
+    end
+
+    it 'includes node in the output if headings are indexed' do
+      # Given
+      site = get_site(algolia: { 'record_css_selector' => 'h1' })
+      hierarchy_page_file = extractor.new(site.file_by_name('hierarchy.md'))
+      nodes = hierarchy_page_file.html_nodes
+      h1 = nodes[0]
+
+      # When
+      actual = hierarchy_page_file.node_hierarchy(h1)
+
+      # Then
+      expect(actual).to include(h1: 'H1')
+    end
+
+    it 'escape html in headings' do
+      # Given
+      nodes = hierarchy_page_file.html_nodes
+      p = nodes[7]
+
+      # When
+      actual = hierarchy_page_file.node_hierarchy(p)
+
+      # Then
+      expect(actual).to include(h3: 'H3B &lt;code&gt;')
+    end
+  end
+
+  describe 'node_raw_html' do
+    it 'returns html including surrounding tags' do
+      # Note: 3rd <p> is a real HTML with a custom class
+      # Given
+      nodes = page_file.html_nodes
+      p = nodes[3]
+
+      # When
+      actual = page_file.node_raw_html(p)
+
+      # Then
+      expect(actual).to eq '<p id="text4">Another text 4</p>'
+    end
+  end
+
+  describe 'node_text' do
+    it 'returns inner text with <> escaped' do
+      # Note: 4th <p> contains a <code> tag with <>
+      # Given
+      nodes = page_file.html_nodes
+      p = nodes[4]
+
+      # When
+      actual = page_file.node_text(p)
+
+      # Then
+      expect(actual).to eq 'Another &lt;text&gt; 5'
+    end
+  end
+
+  describe 'unique_hierarchy' do
+    it 'combines title and headings' do
+      # Given
+      hierarchy = {
+        title: 'title',
+        h1: 'h1',
+        h2: 'h2',
+        h3: 'h3',
+        h4: 'h4',
+        h5: 'h5',
+        h6: 'h6'
+      }
+
+      # When
+      actual = page_file.unique_hierarchy(hierarchy)
+
+      # Then
+      expect(actual).to eq 'title > h1 > h2 > h3 > h4 > h5 > h6'
+    end
+
+    it 'combines title and headings even with missing elements' do
+      # Given
+      hierarchy = {
+        title: 'title',
+        h2: 'h2',
+        h4: 'h4',
+        h6: 'h6'
+      }
+
+      # When
+      actual = page_file.unique_hierarchy(hierarchy)
+
+      # Then
+      expect(actual).to eq 'title > h2 > h4 > h6'
+    end
+  end
+
+  describe 'node_css_selector' do
+    it 'uses the #id to make the selector more precise if one is found' do
+      # Given
+      nodes = page_file.html_nodes
+      p = nodes[3]
+
+      # When
+      actual = page_file.node_css_selector(p)
+
+      # Then
+      expect(actual).to eq '#text4'
+    end
+
+    it 'uses p:nth-of-type if no #id found' do
+      # Given
+      nodes = page_file.html_nodes
+      p = nodes[2]
+
+      # When
+      actual = page_file.node_css_selector(p)
+
+      # Then
+      expect(actual).to eq 'p:nth-of-type(3)'
+    end
+
+    it 'handles custom <div> markup' do
+      # Given
+      nodes = page_file.html_nodes
+      p = nodes[5]
+
+      # When
+      actual = page_file.node_css_selector(p)
+
+      # Then
+      expect(actual).to eq 'div:nth-of-type(2) > p'
+    end
+  end
+
+  describe 'weight' do
+    it 'gets the number of words in text also in the title' do
+      # Given
+      data = {
+        title: 'foo bar',
+        text: 'Lorem ipsum dolor foo bar, consectetur adipiscing elit'
+      }
+
+      # When
+      actual = page_file.weight(data)
+
+      # Then
+      expect(actual).to eq 2
+    end
+
+    it 'gets the number of words in text also in the headings' do
+      # Given
+      data = {
+        title: 'foo',
+        h1: 'bar',
+        h2: 'baz',
+        text: 'Lorem baz dolor foo bar, consectetur adipiscing elit'
+      }
+
+      # When
+      actual = page_file.weight(data)
+
+      # Then
+      expect(actual).to eq 3
+    end
+
+    it 'count each word only once' do
+      # Given
+      data = {
+        title: 'foo',
+        h1: 'foo foo foo',
+        h2: 'bar bar foo bar',
+        text: 'foo bar bar bar bar baz foo bar baz'
+      }
+
+      # When
+      actual = page_file.weight(data)
+
+      # Then
+      expect(actual).to eq 2
+    end
+
+    it 'is case-insensitive' do
+      # Given
+      data = {
+        title: 'FOO',
+        h1: 'bar Bar BAR',
+        text: 'foo BAR'
+      }
+
+      # When
+      actual = page_file.weight(data)
+
+      # Then
+      expect(actual).to eq 2
+    end
+
+    it 'should only use words, no partial matches' do
+      # Given
+      data = {
+        title: 'foo bar',
+        text: 'xxxfooxxx bar'
+      }
+
+      # When
+      actual = page_file.weight(data)
+
+      # Then
+      expect(actual).to eq 1
+
+      # I don't seem fit for that
+    end
+
+    it 'should still work with non-string keys' do
+      # Given
+      data = {
+        title: nil,
+        h1: [],
+        h2: {},
+        h3: true,
+        h4: false,
+        h5: 'foo bar',
+        text: 'foo bar'
+      }
+
+      # When
+      actual = page_file.weight(data)
+
+      # Then
+      expect(actual).to eq 2
+    end
+  end
+
+  describe 'custom_hook_each' do
+    it 'let the user call a custom hook to modify a record' do
+      # Given
+      def page_file.custom_hook_each(item, _)
+        item[:custom_attribute] = 'foo'
+        item
+      end
+
+      # When
+      actual = page_file.extract
+
+      # Then
+      expect(actual[0]).to include(custom_attribute: 'foo')
+    end
+
+    it 'let the user discard a record by returning nil' do
+      # Given
+      def page_file.custom_hook_each(_, _)
+        nil
+      end
+
+      # When
+      actual = page_file.extract
+
+      # Then
+      expect(actual.size).to eq 0
+    end
+  end
+
+  describe 'custom_hook_all' do
+    it 'let the user call a custom hook to modify the list of records' do
+      # Given
+      def page_file.custom_hook_all(items)
+        [items[0], { foo: 'bar' }]
+      end
+
+      # When
+      actual = page_file.extract
+
+      # Then
+      expect(actual.size).to eq 2
+      expect(actual[1]).to include(foo: 'bar')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'awesome_print'
+require_relative './spec_helper_jekyll.rb'
+require_relative './spec_helper_simplecov.rb'
+require './lib/push.rb'
+
+RSpec.configure do |config|
+  config.filter_run(focus: true)
+  config.run_all_when_everything_filtered = true
+
+  # Build a jekyll site, creating access to @__files used internally
+  def get_site(config = {})
+    config = config.merge(
+      source: File.expand_path('./spec/fixtures')
+    )
+    config = Jekyll.configuration(config)
+    site = Jekyll::Site.new(config)
+
+    # Keep a list of all files
+    def site.write
+      @__files = {}
+      each_site_file do |file|
+        @__files[file.path] = file
+      end
+    end
+
+    def site.file_by_name(file_name)
+      @__files.find { |path, _| path =~ /#{file_name}$/ }[1]
+    end
+
+    site.process
+    site
+  end
+end

data/spec/spec_helper_jekyll.rb

@@ -0,0 +1,4 @@
+require 'jekyll'
+
+# Prevent Jekyll from displaying the "Configuration file:..." on every test
+Jekyll.logger.log_level = :error

data/spec/spec_helper_simplecov.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+
+SimpleCov.configure do
+  load_adapter 'test_frameworks'
+end
+
+ENV['COVERAGE'] && SimpleCov.start do
+  add_filter '/.rvm/'
+end