rika 1.11.1-java → 2.0.0-java

data/rika_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Defines some shortcuts for ad-hoc work with Rika.
 #
 # Can be used with the `irb`/`jirb` or `pry` (https://github.com/pry/pry) interactive shells:
@@ -11,28 +13,18 @@
 
 require 'rika'
 
-def c(resource)
-  Rika.parse_content(resource)
-end
-
-def m(resource)
-  Rika.parse_metadata(resource)
+# Add shortuct to Rika.parse.
+def pa(resource)
+  Rika.parse(resource)
 end
 
-def cm(resource)
-  Rika.parse_content_and_metadata(resource)
+# Add abbreviated aliases for the ParseResult class methods.
+class ParseResult
+  alias c content
+  alias m metadata
+  alias l language
+  alias i input_type
+  alias d data_source
+  alias t content_type
+  alias j metadata_java
 end
-
-def cmh(resource)
-  Rika.parse_content_and_metadata_as_hash(resource)
-end
-
-def mj(resource); m(resource).to_json                      ; end
-def mJ(resource); JSON.pretty_generate(m(resource))        ; end
-def my(resource); m(resource).to_yaml                      ; end
-def my(resource); require 'awesome_print'; m(resource).ai  ;end
-
-def cmj(resource); c(resource).to_json;               end
-def cmJ(resource); JSON.pretty_generate(c(resource)); end
-def cmy(resource); c(resource).to_yaml              ; end
-def cma(resource); require 'awesome_print'; c,m = cm(resource); { content: c, metadata: m }; end

data/spec/fixtures/tiny.txt

@@ -0,0 +1 @@
+hello

data/spec/rika/cli/args_parser_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+require 'rika/cli/args_parser'
+
+describe ArgsParser do
+  let(:versions_regex) { /Versions:.*Rika: (\d+\.\d+\.\d+(-\w+)?).*Tika: (\d+\.\d+\.\d+(-\w+)?)/ }
+
+  specify 'returns a hash of options, a target array, and help text' do
+    options, targets, help_text = described_class.call([])
+    expect(options).to be_a(Hash)
+    expect(targets).to be_an(Array)
+    expect(help_text).to be_a(String)
+  end
+
+  context 'when parsing options' do
+    RSpec.shared_examples 'sets_options_correctly' do |args, option_key, expected_value|
+      specify "correctly sets #{option_key} to #{expected_value} when args are #{args}" do
+        options, _, _ = described_class.call(args)
+        expect(options[option_key]).to eq(expected_value)
+      end
+    end
+
+    # Test default option values:
+    include_examples('sets_options_correctly', [], :as_array, false)
+    include_examples('sets_options_correctly', [], :text, true)
+    include_examples('sets_options_correctly', [], :metadata, true)
+    include_examples('sets_options_correctly', [], :format, 'at')
+    include_examples('sets_options_correctly', [], :key_sort, true)
+    include_examples('sets_options_correctly', [], :source, true)
+
+    # Test -a as_array option:
+    include_examples('sets_options_correctly', %w[-a], :as_array, true)
+    include_examples('sets_options_correctly', %w[--as_array], :as_array, true)
+    include_examples('sets_options_correctly', %w[-a -a-], :as_array, false)
+    include_examples('sets_options_correctly', %w[--no-as_array], :as_array, false)
+
+    # Test -f format option:
+    include_examples('sets_options_correctly', %w[-fyy], :format, 'yy')
+    include_examples('sets_options_correctly', %w[--format yy], :format, 'yy')
+    include_examples('sets_options_correctly', %w[-f yy], :format, 'yy')
+    include_examples('sets_options_correctly', %w[-f y], :format, 'yy')
+    include_examples('sets_options_correctly', %w[-f yj], :format, 'yj')
+    include_examples('sets_options_correctly', %w[-f yjJ], :format, 'yj') # Test extra characters after valid format
+
+    # Test -m metadata option:
+    include_examples('sets_options_correctly', %w[-m- -m], :metadata, true)
+    include_examples('sets_options_correctly', %w[-m- -m+], :metadata, true)
+    include_examples('sets_options_correctly', %w[--metadata false --metadata], :metadata, true)
+    include_examples('sets_options_correctly', %w[-m -m-], :metadata, false)
+    include_examples('sets_options_correctly', %w[-m yes], :metadata, true)
+    include_examples('sets_options_correctly', %w[-m no], :metadata, false)
+    include_examples('sets_options_correctly', %w[-m true], :metadata, true)
+    include_examples('sets_options_correctly', %w[-m false], :metadata, false)
+    include_examples('sets_options_correctly', %w[--metadata false], :metadata, false)
+    include_examples('sets_options_correctly', %w[--no-metadata], :metadata, false)
+
+    # Test -t text option:
+    include_examples('sets_options_correctly', %w[-t], :text, true)
+    include_examples('sets_options_correctly', %w[-t -t-], :text, false)
+    include_examples('sets_options_correctly', %w[-t yes], :text, true)
+    include_examples('sets_options_correctly', %w[-t no], :text, false)
+    include_examples('sets_options_correctly', %w[-t true], :text, true)
+    include_examples('sets_options_correctly', %w[-t false], :text, false)
+    include_examples('sets_options_correctly', %w[--text false], :text, false)
+    include_examples('sets_options_correctly', %w[--text false --text], :text, true)
+
+    # Test -k key sort option:
+    include_examples('sets_options_correctly', %w[-k-], :key_sort, false)
+
+    # Test -s source option:
+    include_examples('sets_options_correctly', %w[-s-], :source, false)
+  end
+
+  describe '#versions_string' do
+    specify 'returns a Rika version and a Tika version' do
+      expect(described_class.new.send(:versions_string)).to match(versions_regex)
+    end
+  end
+
+  context 'when processing environment variables' do
+    it 'adds arguments from the environment to the args list' do
+      args_parser = described_class.new
+      allow(args_parser).to receive(:environment_options).and_return('-t-')
+      options, _, _ = args_parser.call([])
+      expect(options[:text]).to be(false)
+    end
+
+    it 'overrides environment variable options with command line options' do
+      env_format_arg = '-fyy'
+      cmd_line_format = 'JJ'
+      cmd_line_args = ["-f#{cmd_line_format}"]
+      args_parser = described_class.new
+      allow(args_parser).to receive(:environment_options).and_return(env_format_arg)
+      options, _, _ = args_parser.call(cmd_line_args)
+      expect(options[:format]).to eq(cmd_line_format)
+    end
+  end
+
+  describe 'DEFAULT_OPTIONS hash' do
+    specify 'has the correct default values' do
+      expect(described_class::DEFAULT_OPTIONS).to eq(
+        as_array: false,
+        text: true,
+        metadata: true,
+        format: 'at',
+        key_sort: true,
+        source: true
+      )
+    end
+
+    specify 'is frozen' do
+      expect(described_class::DEFAULT_OPTIONS).to be_frozen
+    end
+  end
+end

data/spec/rika/cli/rika_command_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika/cli/rika_command'
+
+RF = Rika::Formatters
+
+describe RikaCommand do
+  let(:versions_regex) { /Versions:.*Rika: (\d+\.\d+\.\d+(-\w+)?).*Tika: (\d+\.\d+\.\d+(-\w+)?)/ }
+
+  before do
+    @original_stdout = $stdout
+    @original_stderr = $stderr
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+  end
+
+  after do
+    $stdout = @original_stdout
+    $stderr = @original_stderr
+  end
+
+  describe '#call' do
+    specify 'call should run the command without error' do
+      expect { described_class.new([fixture_path('tiny.txt')]).call }.not_to raise_error
+    end
+
+    specify 'prints version and exits when -v or --version is specified' do
+      expect { described_class.new(%w[-v]).call }.to output(versions_regex).to_stdout.and raise_error(SystemExit)
+    end
+
+    specify 'prints help and exits when -h or --help is specified' do
+      regex = /Usage: rika \[options\] <file or url> /m
+      expect { described_class.new(%w[-h]).call }.to output(regex).to_stdout.and raise_error(SystemExit)
+    end
+
+    specify 'when run in array mode, outputs the string representation of an array of parse results' do
+      original_stdout = $stdout
+      $stdout = StringIO.new
+      begin
+        tiny_filespec = fixture_path('tiny.txt')
+        args = ['-a', '-fJ', tiny_filespec, tiny_filespec]
+        described_class.new(args).call
+        output = $stdout.string
+        object = JSON.parse(output)
+        expect(object).to be_an(Array)
+        expect(object.size).to eq(2)
+        expect(object.map(&:class)).to eq([Hash, Hash])
+      ensure
+        $stdout = original_stdout
+      end
+    end
+  end
+
+  describe '#single_document_output' do
+    RSpec.shared_examples 'verify_result_is_hash' do |format_chars, parser|
+      specify "correctly uses result hash for JSON and YAML when options are #{format_chars}" do
+        original_stdout = $stdout
+        $stdout = StringIO.new
+        begin
+          rika_command = described_class.new(["-f#{format_chars}", fixture_path('tiny.txt')])
+          rika_command.call
+          output = $stdout.string
+          warn output
+          result_hash = parser.call(output)
+          expect(result_hash).to be_a(Hash)
+          expect(result_hash['metadata']).to be_a(Hash)
+          expect(result_hash['text']).to be_a(String)
+        ensure
+          $stdout = original_stdout
+        end
+      end
+    end
+
+    include_examples('verify_result_is_hash', 'JJ', ->(s) { JSON.parse(s) })
+    include_examples('verify_result_is_hash', 'jj', ->(s) { JSON.parse(s) })
+    include_examples('verify_result_is_hash', 'yy', ->(s) { YAML.safe_load(s) })
+  end
+
+  describe '#set_output_formats' do
+    RSpec.shared_examples 'verify_correct_output_formats_selected' \
+      do |format_chars, expected_m_formatter, expected_t_formatter|
+      specify "correctly sets output formats when options are #{format_chars}" do
+        rika_command = described_class.new(["-f#{format_chars}"])
+        rika_command.send(:prepare)
+        expect(rika_command.send(:metadata_formatter)).to eq(expected_m_formatter)
+        expect(rika_command.send(:text_formatter)).to eq(expected_t_formatter)
+      end
+    end
+
+    include_examples('verify_correct_output_formats_selected', 'aj', RF::AWESOME_PRINT_FORMATTER, RF::JSON_FORMATTER)
+    include_examples('verify_correct_output_formats_selected', 'Jy', RF::PRETTY_JSON_FORMATTER,   RF::YAML_FORMATTER)
+    include_examples('verify_correct_output_formats_selected', 'ti', RF::TO_S_FORMATTER,          RF::INSPECT_FORMATTER)
+
+    RSpec.shared_examples 'verify_bad_output_format_exits' do |format_chars|
+      specify "exits when a bad output format is specified with #{format_chars}" do
+        expect { described_class.new(["-f#{format_chars}"]).call }.to raise_error(SystemExit)
+      end
+    end
+
+    include_examples 'verify_bad_output_format_exits', 'ax'
+    include_examples 'verify_bad_output_format_exits', 'xa'
+    include_examples 'verify_bad_output_format_exits', 'x'
+  end
+
+  describe '#warn_if_no_targets_specified' do
+    it 'prints a warning if no targets are specified' do
+      rika_command = described_class.new([])
+      allow(rika_command).to receive_messages(
+        targets: [],
+        help_text: 'sample help text'
+      )
+      expect { rika_command.send(:report_and_exit_if_no_targets_specified) }.to raise_error(SystemExit)
+      expect(rika_command).to have_received(:help_text).once
+      output = $stderr.string
+      expect(output).to match(/No targets specified/)
+      expect(output).to include('sample help text')
+    end
+  end
+end

data/spec/rika/formatters_spec.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika/formatters'
+
+describe Rika::Formatters do
+  describe '.get' do
+    let(:rf) { described_class }
+
+    it 'returns the correct formatter for each option character' do
+      expect(rf.get('a')).to eq(rf::AWESOME_PRINT_FORMATTER)
+      expect(rf.get('i')).to eq(rf::INSPECT_FORMATTER)
+      expect(rf.get('j')).to eq(rf::JSON_FORMATTER)
+      expect(rf.get('J')).to eq(rf::PRETTY_JSON_FORMATTER)
+      expect(rf.get('t')).to eq(rf::TO_S_FORMATTER)
+      expect(rf.get('y')).to eq(rf::YAML_FORMATTER)
+    end
+
+    it 'raises an error if the option character is invalid' do
+      expect { rf.get('x') }.to raise_error(KeyError)
+    end
+  end
+end

data/spec/rika/parse_result_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika/parse_result'
+
+describe Rika::ParseResult do
+  context 'when initialized' do
+    specify 'contains the necessary fields' do
+      expect(described_class.new).to respond_to(
+        :content,
+        :text, # alias for content
+        :metadata,
+        :metadata_java,
+        :content_type,
+        :language,
+        :input_type,
+        :data_source,
+        :max_content_length
+      )
+    end
+  end
+
+  describe '#file?' do
+    specify 'returns true if input_type is :file' do
+      expect(described_class.new(input_type: :file).file?).to be true
+    end
+
+    specify 'returns false if input_type is not :file' do
+      expect(described_class.new.file?).to be false
+    end
+  end
+
+  describe '#http?' do
+    specify 'returns true if input_type is :http' do
+      expect(described_class.new(input_type: :http).http?).to be true
+    end
+
+    specify 'returns false if input_type is not :http' do
+      expect(described_class.new.http?).to be false
+    end
+  end
+end

data/spec/rika/parser_spec.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika/parser'
+require 'rika/parse_result'
+require 'webrick'
+
+describe Rika::Parser do
+  port = 50515
+
+  let(:text_parse_result)    { Rika.parse(fixture_path('document.txt')) }
+  let(:docx_parse_result)    { Rika.parse(fixture_path('document.docx')) }
+  let(:doc_parse_result)     { Rika.parse(fixture_path('document.doc'))  }
+  let(:pdf_parse_result)     { Rika.parse(fixture_path('document.pdf'))  }
+  let(:image_parse_result)   { Rika.parse(fixture_path('image.jpg'))     }
+  let(:unknown_parse_result) { Rika.parse(fixture_path('unknown.bin'))   }
+  let(:fixtures_dir)         { File.expand_path(File.join(File.dirname(__FILE__), '../fixtures')) }
+  let(:quote_first_line) { 'Stopping by Woods on a Snowy Evening' }
+  let(:url) { "http://#{Socket.gethostname}:#{port}" }
+  let(:sample_pdf_filespec) { fixture_path('document.pdf') }
+  let(:first_line) { ->(string) { string.split("\n").first.strip } }
+
+  # returns a lambda that, when passed an action, will wrap it in an HTTP server
+  let(:server_runner) do
+    ->(action) do
+      server = nil
+      server_thread = Thread.new do
+        server = WEBrick::HTTPServer.new(
+          Port:         port,
+          DocumentRoot: fixtures_dir,
+          AccessLog:    [],
+          Logger:       WEBrick::Log.new('/dev/null')
+        )
+        server.start
+      end
+
+      # Wait for server to become ready on its new thread
+      sleep 0.01 while server.nil?
+      begin
+        action.call
+      ensure
+        server.shutdown
+        server_thread.exit
+      end
+    end
+  end
+
+  context 'when initialized with a content string and metadata' do
+    let(:content) { 'Magnifique' }
+    let(:metadata) { { 'author' => 'John Doe' } }
+    let(:result) { Rika::ParseResult.new(content: content, metadata: metadata) }
+
+    specify '#content_and_metadata_hash returns a hash with content and metadata' do
+      expect(result.content_and_metadata_hash).to eq({ content: content, metadata: metadata })
+    end
+  end
+
+  describe '#parse' do
+    let(:parser) { described_class.new('spec/fixtures/document.pdf') }
+    let(:parse_result) { parser.parse }
+    let(:metadata) { parse_result.metadata }
+
+    specify 'returns an instance of ParseResult' do
+      expect(parse_result).to be_a(Rika::ParseResult)
+    end
+
+    specify 'returns a ParseResult with the expected access methods' do
+      expect(parse_result).to respond_to(
+        :content,
+        :metadata,
+        :metadata_java,
+        :content_type,
+        :language,
+        :input_type,
+        :data_source,
+        :max_content_length
+      )
+    end
+
+    specify 'returns a ParseResult with the expected content' do
+      expect(parse_result.content).to include('Stopping by Woods on a Snowy Evening')
+    end
+
+    specify 'returns a ParseResult with the expected metadata' do
+      expect(parse_result.metadata).to include(
+        'dc:creator' => 'Robert Frost',
+        'dc:format' => 'application/pdf; version=1.3',
+        'dc:title' => 'Stopping by Woods on a Snowy Evening',
+        'rika:data-source' => 'spec/fixtures/document.pdf',
+        'rika:language' => 'en'
+      )
+    end
+
+    specify 'returns a ParseResult with the expected metadata_java' do
+      expect(parse_result.metadata_java).to be_a(Java::OrgApacheTikaMetadata::Metadata)
+    end
+
+    specify 'returns a ParseResult with the expected content_type' do
+      expect(parse_result.content_type).to eq('application/pdf')
+    end
+
+    specify 'returns a ParseResult with the expected language' do
+      expect(parse_result.language).to eq('en')
+    end
+
+    specify 'returns a ParseResult with the expected input_type' do
+      expect(parse_result.input_type).to eq(:file)
+    end
+
+    specify 'returns a ParseResult with the expected data_source' do
+      expect(parse_result.data_source).to eq('spec/fixtures/document.pdf')
+    end
+
+    describe 'metadata key sorting' do
+      RSpec.shared_examples('metadata key sorting') do |caption, key_sort|
+        specify "Metadata keys are #{caption} case insensitively when key_sort is #{key_sort}" do
+          parser = described_class.new('spec/fixtures/document.pdf', key_sort: key_sort)
+          keys = parser.parse.metadata.keys
+          expect(keys == keys.sort_by(&:downcase)).to eq(key_sort)
+          expect(keys).not_to eq(keys.map(&:downcase)) # Above test only valid if both upper and lower case occur.
+        end
+      end
+
+      include_examples 'metadata key sorting', 'sorted', true
+      include_examples 'metadata key sorting', 'not sorted', false
+    end
+
+    specify 'returns a ParseResult with the expected max_content_length' do
+      expect(parse_result.max_content_length).to eq(-1)
+    end
+  end
+
+  it 'raises an error if the file does not exist' do
+    expect { Rika.parse(fixture_path('nonexistent_file.txt')) }.to raise_error(IOError)
+  end
+
+  it 'raises an error if the URL does not exist' do
+    unavailable_server = 'http://k6075sd0dfkr8nvfw0zvwfwckucf2aba.com'
+    unavailable_file_on_web = File.join(unavailable_server, 'x.pdf')
+    expect { Rika.parse(unavailable_file_on_web) }.to raise_error(Java::JavaNet::UnknownHostException)
+  end
+
+  it 'detects a file type without a file extension' do
+    parse_result = Rika.parse(fixture_path('image_jpg_without_extension'))
+    expect(parse_result.metadata['Content-Type']).to eq('image/jpeg')
+  end
+
+  describe '#content' do
+    it 'returns the content in a text file' do
+      expect(first_line.(text_parse_result.content)).to eq(quote_first_line)
+    end
+
+    it 'returns the content in a docx file' do
+      expect(first_line.(docx_parse_result.content)).to eq(quote_first_line)
+    end
+
+    it 'returns the content in a pdf file' do
+      # For some reason, the generated PDF file has a newline at the beginning
+      # and trailing spaces on the lines, so we use the second line, and
+      # use `include` to do the text match.
+      expect(pdf_parse_result.content.lines[1]).to include(quote_first_line)
+    end
+
+    it 'returns no content for an image' do
+      expect(image_parse_result.content).to be_empty
+    end
+
+    it 'only returns max content length from a text file' do
+      expect(Rika.parse(fixture_path('document.txt'), max_content_length: 8).content).to eq('Stopping')
+    end
+
+    it 'only returns max content length from a PDF' do
+      expect(Rika.parse(fixture_path('document.pdf'), max_content_length: 9).content).to eq("\nStopping")
+    end
+
+    it 'only returns max content length for file over http' do
+      server_runner.call(-> do
+        content = Rika.parse(File.join(url, 'document.txt'), max_content_length: 8).content
+        expect(content).to eq('Stopping')
+      end)
+    end
+
+    it 'returns the content from a file over http' do
+      content = server_runner.call(-> do
+        Rika.parse(File.join(url, 'document.txt')).content
+      end)
+      expect(first_line.(content)).to eq(quote_first_line)
+    end
+
+    it 'return empty string for unknown file' do
+      expect(unknown_parse_result.content).to be_empty
+    end
+  end
+
+  # We just test a few of the metadata fields for some common file formats
+  # to make sure the integration with Apache Tika works. Apache Tika already
+  # have tests for all file formats it supports so we won't retest that
+  describe '#metadata' do
+    it 'returns nil if metadata field does not exist' do
+      expect(text_parse_result.metadata['nonsense']).to be_nil
+    end
+
+    it 'returns metadata from a docx file' do
+      expect(docx_parse_result.metadata['meta:page-count']).to eq('1')
+    end
+
+    it 'returns metadata from a pdf file' do
+      expect(pdf_parse_result.metadata['pdf:docinfo:creator']).to eq('Robert Frost')
+    end
+
+    it 'returns metadata from a file over http' do
+      server_runner.call(-> do
+        parser = Rika.parse(File.join(url, 'document.pdf'))
+        expect(parser.metadata['pdf:docinfo:creator']).to eq('Robert Frost')
+      end)
+    end
+
+    it 'returns metadata from an image' do
+      expect(image_parse_result.metadata['Image Height']).to eq('72 pixels')
+      expect(image_parse_result.metadata['Image Width']).to  eq('72 pixels')
+    end
+  end
+
+  describe '#content_type' do
+    it 'returns application/pdf for a pdf file' do
+      expect(pdf_parse_result.content_type).to eq('application/pdf')
+    end
+
+    it 'returns text/plain for a txt file' do
+      expect(text_parse_result.content_type).to eq('text/plain; charset=UTF-8')
+    end
+
+    it 'returns application/pdf for a pdf over http' do
+      server_runner.call(-> do
+        parse_result = Rika.parse(File.join(url, 'document.pdf'))
+        expect(parse_result.content_type).to eq('application/pdf')
+      end)
+    end
+
+    it 'returns application/octet-stream for unknown file' do
+      expect(unknown_parse_result.content_type).to eq('application/octet-stream')
+    end
+
+    it 'returns msword for a doc file' do
+      # There seem to be two permissible content types for a doc file.
+      expect(%w{application/msword application/x-tika-msoffice}.include?(doc_parse_result.content_type)).to be true
+    end
+
+    it 'returns wordprocessingml for a docx file' do
+      expect(docx_parse_result.content_type).to eq(
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
+      )
+    end
+  end
+
+  describe '#language' do
+    it 'returns the language of the content' do
+      %w(en de fr ru es).each do |lang|
+        parse_result = Rika.parse(fixture_path("#{lang}.txt"))
+        expect(parse_result.language).to eq(lang)
+      end
+    end
+  end
+
+  it 'returns valid content using Rika.parse_content' do
+    content = Rika.parse_content(sample_pdf_filespec)
+    expect(content).to be_a(String)
+    expect(content).not_to be_empty
+  end
+
+  it 'returns valid metadata using Rika.parse_metadata' do
+    metadata = Rika.parse_metadata(sample_pdf_filespec)
+    expect(metadata).to be_a(Hash)
+    expect(metadata).not_to be_empty
+  end
+
+  it 'returns valid content and metadata using Rika.parse_content_and_metadata' do
+    content, metadata = Rika.parse_content_and_metadata(sample_pdf_filespec)
+    expect(content).to be_a(String)
+    expect(content).not_to be_empty
+    expect(metadata).to be_a(Hash)
+    expect(metadata).not_to be_empty
+  end
+
+  specify 'both means of getting both content and metadata return the same values' do
+    content1, metadata1 = Rika.parse_content_and_metadata(sample_pdf_filespec)
+
+    h = Rika.parse_content_and_metadata_as_hash(sample_pdf_filespec)
+    content2  = h[:content]
+    metadata2 = h[:metadata]
+
+    expect(content1).to eq(content2)
+    expect(metadata1).to eq(metadata2)
+  end
+
+  specify 'getting content and metadata individually and together return the same values' do
+    content1, metadata1 = Rika.parse_content_and_metadata(sample_pdf_filespec)
+    content2             = Rika.parse_content(sample_pdf_filespec)
+    metadata2            = Rika.parse_metadata(sample_pdf_filespec)
+
+    expect(content1).to eq(content2)
+    expect(metadata1).to eq(metadata2)
+  end
+end

data/spec/rika/rika_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'rika'
+
+describe Rika do
+  it 'has a version number' do
+    expect(Rika::VERSION).not_to be_nil
+  end
+end