wordlist 0.1.1 → 1.0.1

data/spec/builder_spec.rb

@@ -1,127 +1,271 @@
+require 'spec_helper'
 require 'wordlist/builder'
 
-require 'spec_helper'
-require 'helpers/text'
-require 'helpers/wordlist'
-require 'builder_examples'
+require 'fileutils'
+
+describe Wordlist::Builder do
+  let(:fixtures_dir) { ::File.join(__dir__,'fixtures') }
+  let(:path)         { ::File.join(fixtures_dir,'new_wordlist.txt') }
+
+  subject { described_class.new(path) }
+
+  describe "#initialize" do
+    it "must initialize the #path" do
+      expect(subject.path).to eq(path)
+    end
 
-describe Builder do
-  include Helpers
+    context "when the path ends in '.txt'" do
+      let(:path) { ::File.join(fixtures_dir,'new_wordlist.txt') }
 
-  describe "new wordlist" do
-    before(:all) do
-      @expected = ['dog', 'cat', 'catx', 'dat']
+      it "must default #format to :txt" do
+        expect(subject.format).to eq(:txt)
+      end
     end
 
-    before(:each) do
-      @path = wordlist_tempfile
+    context "when the path ends in '.gz'" do
+      let(:path) { ::File.join(fixtures_dir,'new_wordlist.gz') }
+
+      it "must default #format to :gzip" do
+        expect(subject.format).to eq(:gzip)
+      end
     end
 
-    it_should_behave_like "a wordlist Builder"
-  end
+    context "when the path ends in '.bz2'" do
+      let(:path) { ::File.join(fixtures_dir,'new_wordlist.bz2') }
 
-  describe "existing wordlist" do
-    before(:all) do
-      @path = '/tmp/bla'
-      @expected = ['dog', 'cat', 'log', 'catx', 'dat']
+      it "must default #format to :bzip2" do
+        expect(subject.format).to eq(:bzip2)
+      end
+    end
+
+    context "when the path ends in '.xz'" do
+      let(:path) { ::File.join(fixtures_dir,'new_wordlist.xz') }
+
+      it "must default #format to :xz" do
+        expect(subject.format).to eq(:xz)
+      end
     end
 
-    before(:each) do
-      @path = wordlist_tempfile(Helpers::PREVIOUS_WORDLIST)
+    context "when format: :txt is given" do
+      subject { described_class.new(path, format: :txt) }
+
+      it "must set #format to :txt" do
+        expect(subject.format).to eq(:txt)
+      end
     end
 
-    it_should_behave_like "a wordlist Builder"
+    context "when format: :gzip is given" do
+      subject { described_class.new(path, format: :gzip) }
+
+      it "must set #format to :gzip" do
+        expect(subject.format).to eq(:gzip)
+      end
+    end
+
+    context "when format: :bzip2 is given" do
+      subject { described_class.new(path, format: :bzip2) }
+
+      it "must set #format to :bzip2" do
+        expect(subject.format).to eq(:bzip2)
+      end
+    end
+
+    context "when format: :xz is given" do
+      subject { described_class.new(path, format: :xz) }
+
+      it "must set #format to :xz" do
+        expect(subject.format).to eq(:xz)
+      end
+    end
+
+    it "must default #append? to false" do
+      expect(subject.append?).to be(false)
+    end
+
+    it "#unique_filter must be empty" do
+      expect(subject.unique_filter).to be_empty
+    end
+
+    it "must open the wordlist file" do
+      expect(subject).to_not be_closed
+    end
+
+    context "when given append: true" do
+      context "and the wordlist file already exists" do
+        let(:path) { ::File.join(fixtures_dir,'pre_existing_wordlist.txt') }
+        let(:pre_existing_words) { %w[foo bar] }
+
+        subject { described_class.new(path, append: true) }
+
+        before do
+          ::File.open(path,'w') do |file|
+            pre_existing_words.each do |word|
+              file.puts word
+            end
+          end
+        end
+
+        it "must add the pre-existing words to the #unique_filter" do
+          expect(pre_existing_words.all? { |word|
+            subject.unique_filter.include?(word)
+          }).to be(true)
+        end
+
+        after { ::FileUtils.rm_f(path) }
+      end
+    end
   end
 
-  describe "word queue" do
-    before(:all) do
-      @path = wordlist_tempfile
+  describe "#lexer" do
+    it "must be a Lexer" do
+      expect(subject.lexer).to be_kind_of(Wordlist::Lexer)
     end
+  end
 
-    before(:each) do
-      @builder = Builder.new(@path, :max_words => 2)
+  describe "#unique_filter" do
+    it "must be a UniqueFilter" do
+      expect(subject.unique_filter).to be_kind_of(Wordlist::UniqueFilter)
     end
+  end
+
+  let(:added_words) { ::File.readlines(path).map(&:chomp) }
 
-    it "should act like a queue" do
-      @builder.enqueue('dog')
-      @builder.enqueue('cat')
+  before { ::FileUtils.rm_f(path) }
 
-      @builder.word_queue.should == ['dog', 'cat']
+  describe "#add" do
+    let(:word) { 'foo' }
+
+    before do
+      described_class.open(path) do |builder|
+        builder.add(word)
+      end
     end
 
-    it "should have a maximum length of the queue" do
-      @builder.enqueue('dog')
-      @builder.enqueue('cat')
-      @builder.enqueue('log')
+    it "must add the word to the file" do
+      expect(added_words).to eq([word])
+    end
+
+    context "when the same word is added multiple times" do
+      before do
+        described_class.open(path) do |builder|
+          builder.add(word)
+          builder.add(word)
+        end
+      end
 
-      @builder.word_queue.should == ['cat', 'log']
+      it "must filter out duplicate words" do
+        expect(File.readlines(path).map(&:chomp)).to eq([word])
+      end
     end
   end
 
-  describe "word combinations" do
-    before(:all) do
-      @path = wordlist_tempfile
+  describe "#append" do
+    let(:words) { %w[foo bar baz] }
+
+    before do
+      described_class.open(path) do |builder|
+        builder.append(words)
+      end
+    end
+
+    it "must add the words to the file" do
+      expect(added_words).to eq(words)
     end
 
-    it "should yield only one word when max_words is set to 1" do
-      builder = Builder.new(@path)
-      builder.enqueue('dog')
+    context "when there are duplicate words in the given Array" do
+      let(:words) { %w[foo bar bar baz] }
 
-      builder.word_combinations do |words|
-        words.should == 'dog'
+      it "must filter out duplicate words" do
+        expect(added_words).to eq(words.uniq)
       end
     end
+  end
 
-    it "should include the last seen word in every combination" do
-      builder = Builder.new(@path, :max_words => 2)
-      builder.enqueue('dog')
-      builder.enqueue('cat')
-      builder.enqueue('dat')
+  describe "#parse" do
+    let(:words) { %w[foo bar baz] }
+    let(:text)  { "foo bar, baz." }
 
-      builder.word_combinations do |words|
-        words.split(' ').include?('dat').should == true
+    before do
+      described_class.open(path) do |builder|
+        builder.parse(text)
       end
     end
 
-    it "should include a minimum number of words" do
-      builder = Builder.new(@path, :min_words => 2, :max_words => 3)
-      builder.enqueue('dog')
-      builder.enqueue('cat')
-      builder.enqueue('dat')
+    it "must parse the text into words and add them to the file" do
+      expect(added_words).to eq(words)
+    end
+
+    context "when the text contains duplicate words" do
+      let(:text)  { "foo bar bar, baz baz." }
 
-      builder.word_combinations do |words|
-        words.split(' ').length.should >= 2
+      it "must filter out duplicate words" do
+        expect(added_words).to eq(words)
       end
     end
+  end
+
+  describe "#parse_file" do
+    let(:text_file) { ::File.join(fixtures_dir,'text_file.txt') }
 
-    it "should not include more than a maximum number of words" do
-      builder = Builder.new(@path, :max_words => 2)
-      builder.enqueue('dog')
-      builder.enqueue('cat')
-      builder.enqueue('dat')
+    let(:words) { %w[foo bar baz] }
+    let(:text)  { "foo bar, baz." }
 
-      builder.word_combinations do |words|
-        words.split(' ').length.should_not > 2
+    before do
+      ::File.write(text_file,text)
+
+      described_class.open(path) do |builder|
+        builder.parse(text)
       end
     end
 
-    it "should preserve the order words were seen in" do
-      builder = Builder.new(@path, :max_words => 3)
-      builder.enqueue('dog')
-      builder.enqueue('cat')
-      builder.enqueue('dat')
+    it "must parse the text file into words and add them to the file" do
+      expect(added_words).to eq(words)
+    end
 
-      combinations = []
+    context "when the text file contains duplicate words" do
+      let(:text)  { "foo bar bar, baz baz." }
 
-      builder.word_combinations do |words|
-        combinations << words
+      it "must filter out duplicate words" do
+        expect(added_words).to eq(words)
       end
+    end
+
+    after { ::FileUtils.rm_f(text_file) }
+  end
+
+  describe "#close" do
+    let(:word) { 'foo' }
+
+    it "must close the wordlist file" do
+      expect(::File.file?(path)).to be(false)
+
+      subject.add(word)
+      subject.close
+
+      expect(::File.file?(path)).to be(true)
+      expect(::File.size(path)).to be > 0
+    end
 
-      combinations.should == [
-        'dat',
-        'cat dat',
-        'dog cat dat'
-      ]
+    it "must clear the unique filter" do
+      expect(subject.unique_filter).to be_empty
     end
   end
+
+  describe "#closed?" do
+    context "when the builder was been initialized" do
+      it "must return false" do
+        expect(subject.closed?).to be(false)
+      end
+    end
+
+    context "when #close has been called" do
+      before { subject.close }
+
+      it "must return true" do
+        expect(subject.closed?).to be(true)
+      end
+    end
+  end
+
+  after { ::FileUtils.rm_f(path) }
 end