change specs

Author: moozzi

spec/fixtures/extra_wordlists/extra_wordlist1.txt

@@ -3,59 +3,78 @@
 require 'ronin/wordlists/exceptions'
 
 describe Ronin::Wordlists::SearchPaths do
-  subject { described_class.new([path]) }
+  subject { described_class.new([path1, path2]) }
 
-  let(:path)         { File.expand_path(File.join(__dir__, '..', 'spec', 'fixtures', 'wordlists')) }
-  let(:wordlist_dir) { Ronin::Wordlists::WordlistDir.new(path) }
+  let(:path1) { File.expand_path(File.join(__dir__, '..', 'spec', 'fixtures', 'wordlists')) }
+  let(:path2) { File.expand_path(File.join(__dir__, '..', 'spec', 'fixtures', 'extra_wordlists')) }
 
   describe "#initialize" do
     it "must initialize #paths and call #<< for each one" do
-      expect(subject.paths[0]).to be_kind_of(Ronin::Wordlists::WordlistDir)
-      expect(subject.paths[0].path).to eq(path)
+      expect(subject.paths).to all(be_kind_of(Ronin::Wordlists::WordlistDir))
+      expect(subject.paths.map(&:path).sort).to eq([path2, path1])
     end
   end
 
   describe ".[]" do
-    it "must initialize SearchPaths instance" do
-      expect(described_class[path]).to be_kind_of(Ronin::Wordlists::SearchPaths)
-      expect(described_class[path].paths[0].path).to eq(path)
+    context "for single path" do
+      subject { described_class[path1] }
+
+      it "must initialize SearchPaths instance" do
+        expect(subject).to be_kind_of(Ronin::Wordlists::SearchPaths)
+        expect(subject.paths.map(&:path)).to eq([path1])
+      end
+    end
+
+    context "for multiple paths" do
+      subject { described_class[path1, path2] }
+
+      it "must initialize SearchPaths instance" do
+        expect(subject).to be_kind_of(Ronin::Wordlists::SearchPaths)
+        expect(subject.paths.map(&:path)).to eq([path2, path1])
+      end
     end
   end
 
   describe "#each" do
-    let(:example_block) { proc { p "test" } }
+    let(:wordlist_dirs) { [Ronin::Wordlists::WordlistDir.new(path2), Ronin::Wordlists::WordlistDir.new(path1)] }
 
     it "must iterate over #paths and yield each directory" do
       yielded_values = []
+
       subject.each do |value|
         yielded_values << value
       end
 
-      expect(yielded_values[0].path).to eq(wordlist_dir.path)
+      expect(yielded_values.size).to eq(2)
+      expect(yielded_values.map(&:path)).to eq(wordlist_dirs.map(&:path))
     end
   end
 
   describe "#<<" do
+    before do
+      subject << path1
+    end
+
     it "must add a new WordlistDir instance to search paths and return self" do
-      expect(subject << path).to be_kind_of(Ronin::Wordlists::SearchPaths)
-      expect((subject << path).paths.size).to eq(3)
+      expect(subject).to be_kind_of(Ronin::Wordlists::SearchPaths)
+      expect(subject.paths.size).to eq(3)
     end
   end
 
   describe "#find" do
-    let(:example_wrodlist_path) { File.join(path, "example_wordlist.txt") }
+    let(:example_wrodlist_path) { File.join(path1, "example_wordlist.txt") }
 
     it "must return wordlist path if it could be found" do
       expect(subject.find("example_wordlist.txt")).to eq(example_wrodlist_path)
     end
 
     it "must return nil if path could not be found" do
-      expect(subject.find("foo")).to eq(nil)
+      expect(subject.find("foo")).to be(nil)
     end
   end
 
   describe "#list" do
-    let(:all_wordlists) { Dir.children(path) }
+    let(:all_wordlists) { [*Dir.children(path1), *Dir.children(path2)] }
 
     context "if argument is not passed" do
       it "must list all wordlists in the wordlist directories" do
@@ -76,10 +95,11 @@
 
   describe "#open" do
     context "if wordlist exist" do
-      let(:example_wrodlist_path) { File.join(path, "example_wordlist.txt") }
+      let(:example_wrodlist_path) { File.join(path1, "example_wordlist.txt") }
 
       it "must call .open on Wordlist with path" do
         expect(Wordlist).to receive(:open).with(example_wrodlist_path)
+
         subject.open("example_wordlist")
       end
     end