moby.rb 1.0.0 → 2.0.0

data/test/Moby/Backends/MechanizeBackend_test.rb

@@ -0,0 +1,83 @@
+# test/Moby/Backends/MechanizeBackend_test.rb
+
+require_relative '../../test_helper'
+
+describe Moby::Backends::MechanizeBackend do
+  let(:url){'https://phishing.example.com/login'}
+  let(:generator){Moby::RandomInputGenerator.new(word_list_path: TestFixtures::WORD_LIST_PATH)}
+
+  def backend(**config_args)
+    config = Moby::Configuration.new(url: url, **config_args)
+    Moby::Backends::MechanizeBackend.new(config: config, random_input_generator: generator)
+  end
+
+  before do
+    WebMock.disable_net_connect!
+    stub_request(:get, url)
+      .to_return(status: 200, body: TestFixtures::SIMPLE_LOGIN_FORM, headers: {'Content-Type' => 'text/html'})
+    stub_request(:post, url).to_return(status: 200, body: 'Success')
+  end
+
+  after do
+    WebMock.reset!
+    WebMock.allow_net_connect!
+  end
+
+  describe "page loading" do
+    it "loads the target url once and memoises the page" do
+      b = backend
+      page1 = b.send(:page)
+      page2 = b.send(:page)
+
+      _(page1).must_be_instance_of(Mechanize::Page)
+      _(page1).must_be_same_as(page2)
+      assert_requested(:get, url, times: 1)
+    end
+  end
+
+  describe "form finding" do
+    it "finds the form by name" do
+      form = backend(form_name: 'login').send(:form)
+
+      _(form).must_be_instance_of(Mechanize::Form)
+      _(form.name).must_equal('login')
+    end
+
+    it "finds the form by number" do
+      multi_url = 'https://multi.example.com/page'
+      stub_request(:get, multi_url)
+        .to_return(status: 200, body: TestFixtures::MULTIPLE_FORMS, headers: {'Content-Type' => 'text/html'})
+      config = Moby::Configuration.new(url: multi_url, form_number: 1)
+      b = Moby::Backends::MechanizeBackend.new(config: config, random_input_generator: generator)
+
+      _(b.send(:form).node['id']).must_equal('login_form')
+    end
+  end
+
+  describe "field finding" do
+    it "finds the username and password fields by name" do
+      b = backend(form_name: 'login', username_field_name: 'username', password_field_name: 'password')
+
+      _(b.send(:username_field).name).must_equal('username')
+      _(b.send(:password_field).name).must_equal('password')
+    end
+  end
+
+  describe "submitting" do
+    it "fills both fields and submits" do
+      backend.send(:fill_and_submit_login_form)
+
+      assert_requested(:post, url) do |request|
+        request.body.match?(/username=[^&]+/) && request.body.match?(/password=[^&]+/)
+      end
+    end
+
+    it "submits only the password when the username is prefilled" do
+      backend(username_prefilled: true).send(:fill_and_submit_login_form)
+
+      assert_requested(:post, url) do |request|
+        request.body.match?(/username=(&|\z)/) && request.body.match?(/password=[^&]+/)
+      end
+    end
+  end
+end

data/test/Moby/Backends/SeleniumBackend_test.rb

@@ -0,0 +1,44 @@
+# test/Moby/Backends/SeleniumBackend_test.rb
+
+require_relative '../../test_helper'
+
+describe Moby::Backends::SeleniumBackend do
+  let(:url){'https://phishing.example.com/login'}
+  let(:generator){Moby::RandomInputGenerator.new(word_list_path: TestFixtures::WORD_LIST_PATH)}
+
+  def backend(**config_args)
+    config = Moby::Configuration.new(url: url, backend: :selenium, **config_args)
+    Moby::Backends::SeleniumBackend.new(config: config, random_input_generator: generator)
+  end
+
+  # Stub the real browser launch so no Chrome/Firefox process is started.
+  def with_stubbed_driver
+    built = 0
+    fake_driver = Object.new
+    original = Selenium::WebDriver.method(:for)
+    Selenium::WebDriver.define_singleton_method(:for) do |*_args, **_kwargs|
+      built += 1
+      fake_driver
+    end
+    begin
+      yield(fake_driver, ->{built})
+    ensure
+      Selenium::WebDriver.define_singleton_method(:for, original)
+    end
+  end
+
+  describe "#driver" do
+    it "builds the driver once and memoises it (returning a non-nil driver)" do
+      with_stubbed_driver do |fake_driver, build_count|
+        b = backend
+        first = b.send(:driver)
+        second = b.send(:driver)
+
+        _(first).wont_be_nil
+        _(first).must_be_same_as(fake_driver)
+        _(first).must_be_same_as(second)
+        _(build_count.call).must_equal(1)
+      end
+    end
+  end
+end

data/test/Moby/Backends_test.rb

@@ -0,0 +1,27 @@
+# test/Moby/Backends_test.rb
+
+require_relative '../test_helper'
+
+describe Moby::Backends do
+  let(:url){'https://phishing.example.com/login'}
+  let(:generator){Moby::RandomInputGenerator.new(word_list_path: TestFixtures::WORD_LIST_PATH)}
+
+  def backend_for(**config_args)
+    config = Moby::Configuration.new(url: url, **config_args)
+    Moby::Backends.for(config: config, random_input_generator: generator)
+  end
+
+  describe ".for" do
+    it "returns a MechanizeBackend for the mechanize configuration" do
+      _(backend_for).must_be_instance_of(Moby::Backends::MechanizeBackend)
+    end
+
+    it "returns a SeleniumBackend for the selenium configuration" do
+      _(backend_for(backend: :selenium)).must_be_instance_of(Moby::Backends::SeleniumBackend)
+    end
+
+    it "raises for an unknown backend" do
+      _(proc{backend_for(backend: :ftp)}).must_raise(RuntimeError)
+    end
+  end
+end

data/test/Moby/Configuration_test.rb

@@ -0,0 +1,134 @@
+# test/Moby/Configuration_test.rb
+
+require_relative '../test_helper'
+
+describe Moby::Configuration do
+  let(:url){'https://phishing.example.com/login'}
+
+  describe "defaults" do
+    let(:config){Moby::Configuration.new(url: url)}
+
+    it "keeps the url" do
+      _(config.url).must_equal(url)
+    end
+
+    it "defaults the backend to mechanize" do
+      _(config.backend).must_equal(:mechanize)
+      _(config.mechanize?).must_equal(true)
+      _(config.selenium?).must_equal(false)
+    end
+
+    it "defaults the browser to chrome" do
+      _(config.browser).must_equal(:chrome)
+    end
+
+    it "defaults form_number to 0" do
+      _(config.form_number).must_equal(0)
+    end
+
+    it "defaults the field names to username and password" do
+      _(config.username_field_name).must_equal('username')
+      _(config.password_field_name).must_equal('password')
+    end
+
+    it "defaults the field numbers to 0 and 1" do
+      _(config.username_field_number).must_equal(0)
+      _(config.password_field_number).must_equal(1)
+    end
+
+    it "runs indefinitely by default" do
+      _(config.iterations).must_be_nil
+      _(config.fixed_number_of_submissions?).must_equal(false)
+    end
+
+    it "defaults the delay to 0" do
+      _(config.delay).must_equal(0)
+    end
+
+    it "is not prefilled, email, verbose or debug by default" do
+      _(config.username_prefilled?).must_equal(false)
+      _(config.username_is_email_address?).must_equal(false)
+      _(config.verbose?).must_equal(false)
+      _(config.debug?).must_equal(false)
+    end
+  end
+
+  describe "backend and browser selection" do
+    it "selects selenium" do
+      _(Moby::Configuration.new(url: url, backend: :selenium).selenium?).must_equal(true)
+    end
+
+    it "coerces a string backend to a symbol" do
+      _(Moby::Configuration.new(url: url, backend: 'selenium').backend).must_equal(:selenium)
+    end
+
+    it "falls back to mechanize when the backend is nil" do
+      _(Moby::Configuration.new(url: url, backend: nil).backend).must_equal(:mechanize)
+    end
+
+    it "falls back to chrome when the browser is nil" do
+      _(Moby::Configuration.new(url: url, browser: nil).browser).must_equal(:chrome)
+    end
+  end
+
+  describe "coercion of string inputs" do
+    let(:config) do
+      Moby::Configuration.new(
+        url: url,
+        form_number: '2',
+        username_field_number: '3',
+        password_field_number: '4',
+        delay: '5',
+        iterations: '6'
+      )
+    end
+
+    it "coerces the numeric switches to integers" do
+      _(config.form_number).must_equal(2)
+      _(config.username_field_number).must_equal(3)
+      _(config.password_field_number).must_equal(4)
+      _(config.delay).must_equal(5)
+      _(config.iterations).must_equal(6)
+    end
+
+    it "treats a given iterations count as a fixed number of submissions" do
+      _(config.fixed_number_of_submissions?).must_equal(true)
+    end
+  end
+
+  describe "#username_is_email_address?" do
+    it "is true when set explicitly" do
+      _(Moby::Configuration.new(url: url, username_is_email_address: true).username_is_email_address?).must_equal(true)
+    end
+
+    it "is truthy when a username hostname is given" do
+      _(Moby::Configuration.new(url: url, username_hostname: 'example.com').username_is_email_address?).wont_equal(false)
+    end
+
+    it "is truthy when the username field is named email" do
+      _(Moby::Configuration.new(url: url, username_field_name: 'email').username_is_email_address?).wont_equal(false)
+    end
+  end
+
+  describe "#user_agent" do
+    it "returns a random agent when not set" do
+      agent = Moby::Configuration.new(url: url).user_agent
+      _(agent).must_be_kind_of(String)
+      _(agent).wont_equal('Mechanize')
+    end
+
+    it "returns the set agent" do
+      _(Moby::Configuration.new(url: url, user_agent: 'CustomAgent').user_agent).must_equal('CustomAgent')
+    end
+  end
+
+  describe "#using_form_name?" do
+    it "is false without a form name" do
+      _(Moby::Configuration.new(url: url).using_form_name?).must_equal(false)
+    end
+
+    it "is true with a form name" do
+      _(Moby::Configuration.new(url: url, form_name: 'login').using_form_name?).must_equal(true)
+    end
+  end
+end

data/test/Moby/RandomInputGenerator_test.rb

@@ -0,0 +1,37 @@
+# test/Moby/RandomInputGenerator_test.rb
+
+require_relative '../test_helper'
+
+describe Moby::RandomInputGenerator do
+  let(:word_list_path){TestFixtures::WORD_LIST_PATH}
+
+  def generator(**args)
+    Moby::RandomInputGenerator.new(word_list_path: word_list_path, **args)
+  end
+
+  describe "#random_username" do
+    it "returns a word from the list by default" do
+      _(TestFixtures::WORDS).must_include(generator.random_username)
+    end
+
+    it "returns an email address when username_is_email_address is true" do
+      _(generator(username_is_email_address: true).random_username).must_match(/\A[^@]+@[^@]+\z/)
+    end
+
+    it "uses the given hostname for the email address" do
+      username = generator(username_hostname: 'example.com', username_is_email_address: true).random_username
+      _(username).must_match(/@example\.com\z/)
+    end
+
+    it "generates more than one distinct username" do
+      usernames = 20.times.map{generator.random_username}
+      _(usernames.uniq.length).must_be(:>, 1)
+    end
+  end
+
+  describe "#random_password" do
+    it "returns a word from the list" do
+      _(TestFixtures::WORDS).must_include(generator.random_password)
+    end
+  end
+end

data/test/Moby/VERSION_test.rb

@@ -16,8 +16,8 @@ describe Moby do
       _(Moby::VERSION).must_match(/\d+\.\d+\.\d+/)
     end
 
-    it "version is 1.0.0" do
-      _(Moby::VERSION).must_equal('1.0.0')
+    it "version is 2.0.0" do
+      _(Moby::VERSION).must_equal('2.0.0')
     end
   end
 end

data/test/moby_test.rb

@@ -4,292 +4,16 @@ require_relative './test_helper'
 
 describe Moby do
   let(:url){'https://phishing.example.com/login'}
-  let(:moby){Moby.new(url: url)}
 
-  before do
-    WebMock.disable_net_connect!
-
-    # Stub the login page
-    stub_request(:get, url)
-      .to_return(
-        status: 200,
-        body: TestFixtures::SIMPLE_LOGIN_FORM,
-        headers: {'Content-Type' => 'text/html'}
-      )
-
-    # Stub form submission
-    stub_request(:post, 'https://phishing.example.com/login')
-      .to_return(status: 200, body: 'Success')
-  end
-
-  after do
-    WebMock.reset!
-    WebMock.allow_net_connect!
-  end
-
-  describe "initialization" do
-    it "accepts url parameter" do
-      _(moby.url).must_equal(url)
-    end
-
-    it "sets default form_number to 0" do
-      _(moby.form_number).must_equal(0)
-    end
-
-    it "sets default username_field_name to 'username'" do
-      _(moby.username_field_name).must_equal('username')
-    end
-
-    it "sets default password_field_name to 'password'" do
-      _(moby.password_field_name).must_equal('password')
-    end
-
-    it "sets default username_field_number to 0" do
-      _(moby.username_field_number).must_equal(0)
-    end
-
-    it "sets default password_field_number to 1" do
-      _(moby.password_field_number).must_equal(1)
-    end
-
-    it "accepts form_name parameter" do
-      m = Moby.new(url: url, form_name: 'login')
-
-      _(m.form_name).must_equal('login')
-    end
-
-    it "accepts username_hostname parameter" do
-      m = Moby.new(url: url, username_hostname: 'example.com')
-
-      _(m.username_hostname).must_equal('example.com')
-    end
-
-    it "accepts username_is_email_address parameter" do
-      m = Moby.new(url: url, username_is_email_address: true)
-
-      _(m.username_is_email_address).must_equal(true)
-    end
-  end
-
-  describe "mechanize setup" do
-    it "creates Mechanize instance lazily" do
-      mech = moby.instance_variable_get(:@mechanize)
-
-      _(mech).must_be_nil
-
-      moby.send(:mechanize)
-      mech = moby.instance_variable_get(:@mechanize)
-
-      _(mech).must_be_instance_of(Mechanize)
-    end
-
-    it "reuses same mechanize instance" do
-      mech1 = moby.send(:mechanize)
-      mech2 = moby.send(:mechanize)
-
-      _(mech1).must_be_same_as(mech2)
-    end
-  end
-
-  describe "page loading" do
-    it "loads the target URL" do
-      page = moby.send(:page)
-
-      _(page).must_be_instance_of(Mechanize::Page)
-      assert_requested(:get, url, times: 1)
-    end
-
-    it "reuses loaded page" do
-      page1 = moby.send(:page)
-      page2 = moby.send(:page)
-
-      _(page1).must_be_same_as(page2)
-      assert_requested(:get, url, times: 1)
-    end
-
-    it "handles meta refresh redirects" do
-      redirect_body = '<html><head><meta http-equiv="Refresh" content="0; url=https://phishing.example.com/real-login"></head></html>'
-
-      stub_request(:get, url)
-        .to_return(status: 200, body: redirect_body, headers: {'Content-Type' => 'text/html'})
-
-      stub_request(:get, 'https://phishing.example.com/real-login')
-        .to_return(status: 200, body: TestFixtures::SIMPLE_LOGIN_FORM, headers: {'Content-Type' => 'text/html'})
-
-      m = Moby.new(url: url)
-      page = m.send(:page)
-
-      assert_requested(:get, url, times: 1)
-      assert_requested(:get, 'https://phishing.example.com/real-login', times: 1)
-    end
-  end
-
-  describe "form finding" do
-    describe "finding by name" do
-      let(:moby) do
-        Moby.new(url: url, form_name: 'login')
-      end
-
-      it "finds form by name when form_name is set" do
-        moby.send(:page)
-        form = moby.send(:form)
-
-        _(form).must_be_instance_of(Mechanize::Form)
-        _(form.name).must_equal('login')
-      end
-    end
-
-    describe "finding by number" do
-      let(:moby) do
-        Moby.new(url: 'https://multi.example.com/page', form_number: 1)
-      end
-
-      it "finds form by number when form_number is set" do
-        stub_request(:get, 'https://multi.example.com/page')
-          .to_return(
-            status: 200,
-            body: TestFixtures::MULTIPLE_FORMS,
-            headers: {'Content-Type' => 'text/html'}
-          )
-        moby.send(:page)
-        form = moby.send(:form)
-
-        _(form).must_be_instance_of(Mechanize::Form)
-        _(form.node['id']).must_equal('login_form')
-      end
-    end
-
-    describe "deafult form" do
-      it "defaults to first form" do
-        moby.send(:page)
-        form = moby.send(:form)
-
-        _(form).must_be_instance_of(Mechanize::Form)
-      end
-    end
-  end
-
-  describe "field finding" do
-    describe "finding by name" do
-      let(:moby) do
-        Moby.new(url: url, form_name: 'login', username_field_name: 'username', password_field_name: 'password')
-      end
-
-      it "finds username field by name" do
-        moby.send(:page)
-        moby.send(:form)
-        field = moby.send(:username_field)
-
-        _(field.name).must_equal('username')
-      end
-
-      it "finds password field by name" do
-        moby.send(:page)
-        moby.send(:form)
-        field = moby.send(:password_field)
-
-        _(field.name).must_equal('password')
-      end
-    end
-
-    describe "finding by number" do
-      let(:moby) do
-        Moby.new(url: url, username_field_number: 0, password_field_number: 1)
-      end
-
-      it "finds username field by number" do
-        moby.send(:page)
-        moby.send(:form)
-        field = moby.send(:username_field)
-
-        _(field).wont_be_nil
-      end
-
-      it "finds password field by number" do
-        moby.send(:page)
-        moby.send(:form)
-        field = moby.send(:password_field)
-
-        _(field).wont_be_nil
-      end
-    end
-  end
-
-  describe "#username" do
-    it "generates random username" do
-      username = moby.send(:username)
-
-      _(username).must_be_kind_of(String)
-      _(username.length).must_be(:>, 0)
-    end
-
-    it "generates email address when username_is_email_address is true" do
-      m = Moby.new(url: url, username_is_email_address: true)
-      username = m.send(:username)
-
-      _(username).must_match(/@/)
-    end
-
-    it "generates email with custom hostname" do
-      m = Moby.new(url: url, username_hostname: 'example.com')
-      username = m.send(:username)
-
-      _(username).must_match(/@example\.com$/)
-    end
-
-
-    it "generates different usernames" do
-      usernames = 10.times.map{moby.send(:username)}
-
-      _(usernames.uniq.length).must_be(:>, 1)
-    end
+  it "selects the mechanize backend by default" do
+    _(Moby.new(url: url).send(:backend)).must_be_instance_of(Moby::Backends::MechanizeBackend)
   end
 
-  describe "#password" do
-    it "generates random password" do
-      password = moby.send(:password)
-
-      _(password).must_be_kind_of(String)
-      _(password.length).must_be(:>, 0)
-    end
+  it "selects the selenium backend when configured" do
+    _(Moby.new(url: url, backend: :selenium).send(:backend)).must_be_instance_of(Moby::Backends::SeleniumBackend)
   end
 
-  describe "#user_agent" do
-    it "returns random user agent when not set" do
-      agent = moby.send(:user_agent)
-
-      _(agent).must_be_kind_of(String)
-      _(agent).wont_equal('Mechanize')
-    end
-
-    it "returns set user agent when provided" do
-      m = Moby.new(url: url, user_agent: 'CustomAgent')
-
-      _(m.send(:user_agent)).must_equal('CustomAgent')
-    end
-
-    it "generates different random agents" do
-      agents = 10.times.map{Moby.new(url: url).send(:user_agent)}
-
-      _(agents.uniq.length).must_be(:>, 1)
-    end
-  end
-
-  describe "#username_is_email_address?" do
-    it "returns true when username_is_email_address is set" do
-      m = Moby.new(url: url, username_is_email_address: true)
-
-      _(m.send(:username_is_email_address?)).must_equal(true)
-    end
-
-    it "returns true when username_hostname is set" do
-      m = Moby.new(url: url, username_hostname: 'example.com')
-
-      _(m.send(:username_is_email_address?)).wont_be_nil
-    end
-
-    it "returns false by default" do
-      _(moby.send(:username_field_name)).must_equal('username')
-    end
+  it "responds to counter_phish" do
+    _(Moby.new(url: url)).must_respond_to(:counter_phish)
   end
 end

data/test/test_helper.rb

@@ -3,6 +3,7 @@
 require 'minitest/autorun'
 require 'minitest-spec-context'
 require 'webmock/minitest'
+require 'tempfile'
 
 require_relative '../lib/moby'
 
@@ -33,4 +34,18 @@ module TestFixtures
       </body>
     </html>
   HTML
+
+  WORDS = %w{
+    alpha bravo charlie delta echo foxtrot golf hotel india juliet
+    kilo lima mike november oscar papa quebec romeo sierra tango
+    uniform victor whiskey xray yankee zulu apple banana cherry date
+    elder fig grape honey iris jasmine kiwi lemon mango nutmeg
+  }.freeze
+
+  WORD_LIST_FILE = Tempfile.new('moby_words').tap do |file|
+    file.write(WORDS.join("\n") << "\n")
+    file.flush
+  end
+
+  WORD_LIST_PATH = WORD_LIST_FILE.path
 end