ronin-db 0.1.0.beta1 → 0.1.0.beta3

data/spec/cli/commands/add_spec.rb

@@ -1,220 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,237 +0,0 @@
-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

data/spec/cli/ruby_shell_spec.rb

@@ -1,14 +0,0 @@
-require 'spec_helper'
-require 'ronin/db/cli/ruby_shell'
-
-describe Ronin::DB::CLI::RubyShell do
-  describe "#initialize" do
-    it "must default #name to 'ronin-db'" do
-      expect(subject.name).to eq('ronin-db')
-    end
-
-    it "must default #context to Ronin::DB" do
-      expect(subject.context).to be(Ronin::DB)
-    end
-  end
-end