ronin-db 0.1.0.beta1-java

data/man/ronin-db-urls.1.md

@@ -0,0 +1,73 @@
+# ronin-db-urls 1 "April 2012" Ronin "User Manuals"
+
+## SYNOPSIS
+
+`ronin-db urls` [*options*]
+
+## DESCRIPTION
+
+Manages URLs.
+
+## OPTIONS
+
+`--db` *NAME*
+  The database to connect to. Defaults to `default` if not given.
+
+`--db-uri` *URI*
+  The explicit database URI to connect to
+  (ex: `mysql://user:password@host/ronin`).
+
+`-v`, `--verbose`
+	Enable verbose output.
+
+`--add` *USER*:*PASSWORD*
+  Adds the *USER* and *PASSWORD* to the database.
+
+`--import` *FILE*
+  Imports the credentials from the given *FILE*.
+
+`--delete` *VALUE*
+  Deletes a value from the database.
+
+`--delete-all`
+  Deletes every value from the database.
+
+`--http`
+	Searches for `http://` URLs.
+
+`--https`
+	Searches for `https://` URLs.
+
+`-H`, `--host` *HOST*
+	Searches for URLs with the given *HOST*.
+
+`-p`, `--with-port` *PORT*
+	Searches for URLs associated with the *PORT*.
+
+`-d`, `--directory` *DIRECTORY*
+	Searches for URLs sharing the DIRECTORY.
+
+`-q`, `--with-query-param` *NAME* [...]
+	Searches for URLs containing the query-param NAME.
+
+`-Q`, `--with-query-value` *VALUE* [...]
+	Searches for URLs containing the query-param VALUE.
+
+## FILES
+
+*~/.ronin/*
+	Ronin configuration directory.
+
+*~/.ronin/database.log*
+	Database log.
+
+*~/.ronin/database.sqlite3*
+	The default sqlite3 Database file.
+
+*~/.ronin/database.yml*
+	Optional Database configuration.
+
+## AUTHOR
+
+Postmodern <postmodern.mod3@gmail.com>
+

data/ronin-db.gemspec

@@ -0,0 +1,78 @@
+# encoding: utf-8
+
+require 'yaml'
+
+Gem::Specification.new do |gem|
+  gemspec = YAML.load_file('gemspec.yml')
+
+  gem.name    = gemspec.fetch('name')
+  gem.version = gemspec.fetch('version') do
+                  lib_dir = File.join(File.dirname(__FILE__),'lib')
+                  $LOAD_PATH << lib_dir unless $LOAD_PATH.include?(lib_dir)
+
+                  require 'ronin/db/version'
+                  Ronin::DB::VERSION
+                end
+
+  gem.summary     = gemspec['summary']
+  gem.description = gemspec['description']
+  gem.licenses    = Array(gemspec['license'])
+  gem.authors     = Array(gemspec['authors'])
+  gem.email       = gemspec['email']
+  gem.homepage    = gemspec['homepage']
+  gem.metadata    = gemspec['metadata'] if gemspec['metadata']
+
+  glob = lambda { |patterns| gem.files & Dir[*patterns] }
+
+  gem.files  = `git ls-files`.split($/)
+  gem.files  = glob[gemspec['files']] if gemspec['files']
+  gem.files += Array(gemspec['generated_files'])
+
+  gem.executables = gemspec.fetch('executables') do
+    glob['bin/*'].map { |path| File.basename(path) }
+  end
+  gem.default_executable = gem.executables.first if Gem::VERSION < '1.7.'
+
+  gem.extensions       = glob[gemspec['extensions'] || 'ext/**/extconf.rb']
+  gem.test_files       = glob[gemspec['test_files'] || 'spec/{**/}*_spec.rb']
+  gem.extra_rdoc_files = glob[gemspec['extra_doc_files'] || '*.{txt,md}']
+
+  gem.require_paths = Array(gemspec.fetch('require_paths') {
+    %w[ext lib].select { |dir| File.directory?(dir) }
+  })
+
+  gem.requirements              = gemspec['requirements']
+  gem.required_ruby_version     = gemspec['required_ruby_version']
+  gem.required_rubygems_version = gemspec['required_rubygems_version']
+  gem.post_install_message      = gemspec['post_install_message']
+
+  split = lambda { |string| string.split(/,\s*/) }
+
+  if RUBY_PLATFORM =~ /java/
+    gem.platform = Gem::Platform.new("java")
+
+    if gemspec['jruby_dependencies']
+      gemspec['jruby_dependencies'].each do |name,versions|
+        gem.add_dependency(name,split[versions])
+      end
+    end
+  else
+    if gemspec['ruby_dependencies']
+      gemspec['ruby_dependencies'].each do |name,versions|
+        gem.add_dependency(name,split[versions])
+      end
+    end
+  end
+
+  if gemspec['dependencies']
+    gemspec['dependencies'].each do |name,versions|
+      gem.add_dependency(name,split[versions])
+    end
+  end
+
+  if gemspec['development_dependencies']
+    gemspec['development_dependencies'].each do |name,versions|
+      gem.add_development_dependency(name,split[versions])
+    end
+  end
+end

data/spec/cli/commands/add_spec.rb

@@ -0,0 +1,220 @@
+require 'spec_helper'
+require 'ronin/db/cli/commands/add'
+
+describe Ronin::DB::CLI::Commands::Add do
+  describe "options" do
+    before { subject.parse_options(argv) }
+
+    describe "--adapter" do
+      let(:adapter) { 'sqlite3' }
+      let(:argv)    { ['--adapter', adapter] }
+
+      it "must set #config[:adapter]" do
+        expect(subject.config[:adapter]).to eq(adapter)
+      end
+    end
+
+    describe "--sqlite3" do
+      let(:database) { '/path/to/file.sqlite3' }
+      let(:argv)     { ['--sqlite3', database] }
+
+      it "must set #config[:adapter] to 'sqlite3'" do
+        expect(subject.config[:adapter]).to eq('sqlite3')
+      end
+
+      it "must set #config[:database] to the given path" do
+        expect(subject.config[:database]).to eq(database)
+      end
+
+      context "when the argument is a relative path" do
+        let(:database) { 'file.sqlite3' }
+
+        it "must expand the relative path before setting #config[:database]" do
+          expect(subject.config[:database]).to eq(File.expand_path(database))
+        end
+      end
+    end
+
+    describe "--mysql2" do
+      let(:argv) { ['--mysql2'] }
+
+      it "must set #config[:adapter] to 'mysql2'" do
+        expect(subject.config[:adapter]).to eq('mysql2')
+      end
+    end
+
+    describe "--postgresql" do
+      let(:argv) { ['--postgresql'] }
+
+      it "must set #config[:adapter] to 'postgresql'" do
+        expect(subject.config[:adapter]).to eq('postgresql')
+      end
+    end
+
+    describe "--host" do
+      let(:host) { 'example.com'    }
+      let(:argv) { ['--host', host] }
+
+      it "must set #config[:host]" do
+        expect(subject.config[:host]).to eq(host)
+      end
+    end
+
+    describe "--port" do
+      let(:port) { 1234 }
+      let(:argv) { ['--port', port.to_s] }
+
+      it "must set #config[:port]" do
+        expect(subject.config[:port]).to eq(port)
+      end
+    end
+
+    describe "--username" do
+      let(:username) { 'foo' }
+      let(:argv)     { ['--username', username] }
+
+      it "must set #config[:username]" do
+        expect(subject.config[:username]).to eq(username)
+      end
+    end
+
+    describe "--password" do
+      let(:password) { 'secret' }
+      let(:argv)     { ['--password', password] }
+
+      it "must set #config[:password]" do
+        expect(subject.config[:password]).to eq(password)
+      end
+    end
+
+    describe "--database" do
+      let(:database) { 'foo' }
+      let(:argv)     { ['--database', database] }
+
+      it "must set #config[:database]" do
+        expect(subject.config[:database]).to eq(database)
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "must initialize #config to an empty Hash" do
+      expect(subject.config).to eq({})
+    end
+  end
+
+  describe "#run" do
+    let(:adapter)  { 'sqlite3' }
+    let(:database) { '/path/to/test.sqlite3' }
+    let(:name)     { 'test' }
+
+    let(:config_file_hash) { {} }
+
+    context "when given a URI argument" do
+      let(:uri) { "#{adapter}:#{database}" }
+
+      it "must parse the URI, call ConfigFile.edit, and add #config to it with the given NAME argument" do
+        expect(Ronin::DB::ConfigFile).to receive(:edit).and_yield(config_file_hash)
+
+        subject.run(name,uri)
+
+        expect(config_file_hash[name]).to eq(
+          {
+            adapter:  adapter,
+            database: database
+          }
+        )
+      end
+    end
+
+    context "when given options instead of a URI argument" do
+      let(:argv) do
+        [
+          '--adapter',  adapter,
+          '--database', database
+        ]
+      end
+
+      before { subject.parse_options(argv) }
+
+      it "must call ConfigFile.edit and add #config to it with the given NAME argument" do
+        expect(Ronin::DB::ConfigFile).to receive(:edit).and_yield(config_file_hash)
+
+        subject.run(name)
+
+        expect(config_file_hash[name]).to eq(
+          {
+            adapter:  adapter,
+            database: database
+          }
+        )
+      end
+    end
+
+    context "when #config[:adapter] is not set" do
+      let(:argv) { ['--database', '/path/to/db.sqlite3'] }
+
+      before { subject.parse_options(argv) }
+
+      it "must print an error message and exit with 1" do
+        expect {
+          subject.run(name)
+        }.to output("add: must specify a URI or the --adapter option#{$/}").to_stderr.and(raise_error(SystemExit))
+      end
+    end
+
+    context "when #config[:database] is not set" do
+      let(:argv) { ['--adapter', 'sqlite3'] }
+
+      before { subject.parse_options(argv) }
+
+      it "must print an error message and exit with 1" do
+        expect {
+          subject.run(name)
+        }.to output("add: must specify a URI or the --database option#{$/}").to_stderr.and(raise_error(SystemExit))
+      end
+    end
+  end
+
+  describe "#read_password" do
+    let(:password) { 'secret' }
+
+    it "must call #ask_secret with 'Password' and set config[:password]" do
+      expect(subject).to receive(:ask_secret).with('Password').and_return(password)
+
+      subject.read_password
+
+      expect(subject.config[:password]).to eq(password)
+    end
+  end
+
+  describe "#validate_config!" do
+    context "when #config[:adapter] is not set" do
+      before do
+        subject.config[:database] = '/path/to/db.sqlite3'
+      end
+
+      it "must print an error message and exit with 1" do
+        expect(subject).to receive(:exit).with(1)
+
+        expect {
+          subject.validate_config!
+        }.to output("add: must specify a URI or the --adapter option#{$/}").to_stderr
+      end
+    end
+
+    context "when #config[:database] is not set" do
+      before do
+        subject.config[:adapter] = 'sqlite3'
+      end
+
+      it "must print an error message and exit with 1" do
+        expect(subject).to receive(:exit).with(1)
+
+        expect {
+          subject.validate_config!
+        }.to output("add: must specify a URI or the --database option#{$/}").to_stderr
+      end
+    end
+  end
+end

data/spec/cli/commands/edit_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'ronin/db/cli/commands/edit'
+
+describe Ronin::DB::CLI::Commands::Edit do
+  describe "#run" do
+    it "must edit the ConfigFile::PATH" do
+      expect(subject).to receive(:edit).with(Ronin::DB::ConfigFile::PATH)
+
+      subject.run
+    end
+  end
+end

data/spec/cli/commands/irb_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'ronin/db/cli/commands/irb'
+
+describe Ronin::DB::CLI::Commands::Irb do
+  describe "#run" do
+    it "must call #connet, then #load_models, then CLI::RubyShell.start" do
+      expect(subject).to receive(:connect)
+      expect(subject).to receive(:load_models)
+      expect(Ronin::DB::CLI::RubyShell).to receive(:start)
+
+      subject.run
+    end
+
+    context "when #options[:no_connect] is set" do
+      before { subject.options[:no_connect] = true }
+
+      it "must not call #connet or #load_models" do
+        expect(subject).to_not receive(:connect)
+        expect(subject).to_not receive(:load_models)
+        expect(Ronin::DB::CLI::RubyShell).to receive(:start)
+
+        subject.run
+      end
+    end
+  end
+end

data/spec/cli/database_command_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'ronin/db/cli/database_command'
+
+describe Ronin::DB::CLI::DatabaseCommand do
+  describe "#config" do
+    context "when neither options[:db] nor options[:db_uri] are set" do
+      it "must default to connecting to the :default database" do
+        expect(subject.config).to eq(Ronin::DB.config[:default])
+      end
+    end
+
+    context "when options[:db] is set" do
+      let(:db_name) { :test }
+      let(:config) do
+        {
+          db_name => {
+            adapter: 'sqlite3',
+            database: '/path/to/db.sqlite3'
+          }
+        }
+      end
+
+      before do
+        allow(Ronin::DB).to receive(:config).and_return(config)
+
+        subject.options[:db] = db_name
+      end
+
+      it "must return the database configuration for options[:db]" do
+        expect(subject.config).to eq(Ronin::DB.config[db_name])
+      end
+    end
+
+    context "when options[:db_uri] is set" do
+      let(:db_uri)     { "postgres://user:password@host:1234/database" }
+      let(:parsed_uri) { subject.parse_uri(subject.options[:db_uri])   }
+
+      before { subject.options[:db_uri] = db_uri }
+
+      it "must return the parsed URI for options[:db_uri]" do
+        expect(subject.config).to eq(parsed_uri)
+      end
+    end
+  end
+
+  describe "#connect" do
+    it "must call ActiveRecord::Base.establish_connection with #config" do
+      expect(ActiveRecord::Base).to receive(:establish_connection).with(subject.config)
+
+      subject.connect
+    end
+  end
+end

data/spec/cli/model_command_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+require 'ronin/db/cli/model_command'
+require 'ronin/db/ip_address'
+require 'ronin/db/host_name'
+
+describe Ronin::DB::CLI::ModelCommand do
+  it "must inherit from Ronin::DB::CLI::DatabaseCommand" do
+    expect(described_class).to be < Ronin::DB::CLI::DatabaseCommand
+  end
+
+  describe ".model_file" do
+    subject { test_class }
+
+    context "and when model_file is not set in the class" do
+      module TestModelCommand
+        class WithNoModelFileSet < Ronin::DB::CLI::ModelCommand
+        end
+      end
+
+      let(:test_class) { TestModelCommand::WithNoModelFileSet }
+
+      it do
+        expect {
+          subject.model_file
+        }.to raise_error(NotImplementedError,"#{subject} did not define model_file")
+      end
+    end
+
+    context "and when model_file is set in the class" do
+      module TestModelCommand
+        class WithModelFileSet < Ronin::DB::CLI::ModelCommand
+          model_file 'ronin/db/test'
+        end
+      end
+
+      let(:test_class) { TestModelCommand::WithModelFileSet }
+
+      it "must return the set model_file" do
+        expect(subject.model_file).to eq('ronin/db/test')
+      end
+    end
+
+    context "but when the model_file was set in the superclass" do
+      module TestModelCommand
+        class InheritsItsModelFile < WithModelFileSet
+        end
+      end
+
+      let(:test_class) { TestModelCommand::InheritsItsModelFile }
+
+      it "must return the model_file set in the superclass" do
+        expect(subject.model_file).to eq('ronin/db/test')
+      end
+
+      context "but the model_file is overridden in the sub-class" do
+        module TestModelCommand
+          class OverridesItsInheritedModelFile < WithModelFileSet
+            model_file 'ronin/db/test2'
+          end
+        end
+
+        let(:test_class) do
+          TestModelCommand::OverridesItsInheritedModelFile
+        end
+
+        it "must return the model_file set in the sub-class" do
+          expect(subject.model_file).to eq('ronin/db/test2')
+        end
+
+        it "must not modify the superclass'es model_file" do
+          expect(subject.superclass.model_file).to eq('ronin/db/test')
+        end
+      end
+    end
+  end
+
+  describe ".model_name" do
+    subject { test_class }
+
+    context "and when model_name is not set in the class" do
+      module TestModelCommand
+        class WithNoModelNameSet < Ronin::DB::CLI::ModelCommand
+        end
+      end
+
+      let(:test_class) { TestModelCommand::WithNoModelNameSet }
+
+      it do
+        expect {
+          subject.model_name
+        }.to raise_error(NotImplementedError,"#{subject} did not define model_name")
+      end
+    end
+
+    context "and when model_name is set in the class" do
+      module TestModelCommand
+        class WithModelNameSet < Ronin::DB::CLI::ModelCommand
+          model_name 'Test'
+        end
+      end
+
+      let(:test_class) { TestModelCommand::WithModelNameSet }
+
+      it "must return the set model_name" do
+        expect(subject.model_name).to eq('Test')
+      end
+    end
+
+    context "but when the model_name was set in the superclass" do
+      module TestModelCommand
+        class InheritsItsModelName < WithModelNameSet
+        end
+      end
+
+      let(:test_class) { TestModelCommand::InheritsItsModelName }
+
+      it "must return the model_name set in the superclass" do
+        expect(subject.model_name).to eq('Test')
+      end
+
+      context "but the model_name is overridden in the sub-class" do
+        module TestModelCommand
+          class OverridesItsInheritedModelName < WithModelNameSet
+            model_name 'Test2'
+          end
+        end
+
+        let(:test_class) do
+          TestModelCommand::OverridesItsInheritedModelName
+        end
+
+        it "must return the model_name set in the sub-class" do
+          expect(subject.model_name).to eq('Test2')
+        end
+
+        it "must not modify the superclass'es model_name" do
+          expect(subject.superclass.model_name).to eq('Test')
+        end
+      end
+    end
+  end
+
+  describe ".model_name" do
+  end
+
+  module TestModelCommand
+    class TestCommand < Ronin::DB::CLI::ModelCommand
+      model_file 'ronin/db/ip_address'
+      model_name 'IPAddress'
+    end
+  end
+
+  let(:test_command) { TestModelCommand::TestCommand }
+  subject { test_command.new }
+
+  describe "#initialize" do
+    it "must initialize #query_method_calls to an empty Array" do
+      expect(subject.query_method_calls).to eq([])
+    end
+  end
+
+  describe "#model" do
+    it "must resolve the class for the model within Ronin::DB::" do
+      expect(subject.model).to be(Ronin::DB.const_get(subject.class.model_name))
+    end
+  end
+
+  describe "#query" do
+    let(:host)   { 'example.com'   }
+    let(:ipv4)   { '93.184.216.34' }
+    let(:ipv6)   { '2606:2800:220:1:248:1893:25c8:1946' }
+
+    before do
+      host_name = Ronin::DB::HostName.create(name: host)
+
+      Ronin::DB::IPAddress.create(address: '127.0.0.1', version: 4)
+      Ronin::DB::IPAddress.create(
+        address:    ipv4,
+        version:    4,
+        host_names: [host_name]
+      )
+      Ronin::DB::IPAddress.create(
+        address:    ipv6,
+        version:    6,
+        host_names: [host_name]
+      )
+      Ronin::DB::IPAddress.create(address: '::1', version: 6)
+    end
+
+    context "when #query_method_calls is empty" do
+      it "must return a ActiveRecord_Relation object" do
+        expect(subject.query).to be_kind_of(
+          subject.model.const_get('ActiveRecord_Relation')
+        )
+      end
+    end
+
+    context "when #query_method_calls contains a :where method call" do
+      before do
+        subject.query_method_calls << [:where, [], {version: 4}]
+      end
+
+      it "must invoke #where with the given arguments on the query" do
+        expect(subject.query).to eq(
+          Ronin::DB::IPAddress.where(version: 4)
+        )
+      end
+    end
+
+    context "when #query_method_calls contains a scoped query method call" do
+      before do
+        subject.query_method_calls << [:with_host_name, [host]]
+      end
+
+      it "must invoke the scoped query method on the query" do
+        expect(subject.query).to eq(
+          Ronin::DB::IPAddress.with_host_name(host)
+        )
+      end
+    end
+
+    after do
+      Ronin::DB::IPAddress.destroy_all
+      Ronin::DB::HostName.destroy_all
+    end
+  end
+
+  describe "#print_record" do
+    let(:record) { Ronin::DB::IPAddress.new(address: '127.0.0.1') }
+
+    it "must print the record using #puts" do
+      expect {
+        subject.print_record(record)
+      }.to output("#{record}#{$/}").to_stdout
+    end
+  end
+end