ronin-support 0.5.2 → 1.0.0.beta1

data/spec/network/unix_spec.rb

@@ -1,182 +0,0 @@
-require 'spec_helper'
-require 'network/shared/unix_server'
-require 'ronin/network/unix'
-
-require 'fileutils'
-
-describe Network::UNIX do
-  describe "helper methods", :network do
-    subject do
-      obj = Object.new
-      obj.extend described_class
-      obj
-    end
-
-    describe "#unix_open?" do
-      include_context "UNIX Server"
-
-      it "should return true for listening UNIX sockets" do
-        expect(subject.unix_open?(path)).to be(true)
-      end
-
-      it "should return false for closed UNIX sockets" do
-        old_path = socket_path('ronin_old_unix_socket')
-        UNIXServer.new(old_path).close
-
-        expect(subject.unix_open?(old_path)).to be(false)
-
-        FileUtils.rm(old_path)
-      end
-
-      it "should have a timeout for non-existent UNIX sockets" do
-        bad_path = socket_path('ronin_bad_unix_socket')
-        timeout  = 2
-
-        t1 = Time.now
-        subject.unix_open?(bad_path,timeout)
-        t2 = Time.now
-
-        expect((t2 - t1).to_i).to be <= timeout
-      end
-    end
-
-    describe "#unix_connect" do
-      include_context "UNIX Server"
-
-      it "should open a UNIXSocket" do
-        socket = subject.unix_connect(path)
-
-        expect(socket).to be_kind_of(UNIXSocket)
-        expect(socket).not_to be_closed
-
-        socket.close
-      end
-
-      it "should yield the new UNIXSocket" do
-        socket = nil
-
-        subject.unix_connect(path) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        expect(socket).not_to be_closed
-        socket.close
-      end
-    end
-
-    describe "#unix_connect_and_send" do
-      include_context "UNIX Server"
-
-      let(:data) { "HELO ronin\n" }
-
-      it "should connect and then send data" do
-        socket   = subject.unix_connect_and_send(data,path)
-        response = socket.readline
-
-        expect(response).to eq(data)
-
-        socket.close
-       end
-
-      it "should yield the UNIXSocket" do
-        response = nil
-
-        socket = subject.unix_connect_and_send(data,path) do |socket|
-          response = socket.readline
-        end
-
-        expect(response).to eq(data)
-
-        socket.close
-      end
-    end
-
-    describe "#unix_session" do
-      include_context "UNIX Server"
-
-      it "should open then close a UNIXSocket" do
-        socket = nil
-
-        subject.unix_session(path) do |yielded_socket|
-          socket = yielded_socket
-        end
-
-        expect(socket).to be_kind_of(UNIXSocket)
-        expect(socket).to be_closed
-      end
-    end
-
-    describe "#unix_send" do
-      let(:server_path) { File.join(Dir.tmpdir,'ronin_unix_server') }
-      let(:data)        { "hello\n" }
-
-      before(:each) { @server = UNIXServer.new(server_path) }
-
-      it "should send data to a service" do
-        subject.unix_send(data,server_path)
-
-        client = @server.accept
-        sent   = client.readline
-
-        client.close
-
-        expect(sent).to eq(data)
-      end
-
-      after(:each) do
-        @server.close
-
-        FileUtils.rm(server_path)
-      end
-    end
-
-    describe "#unix_server" do
-      let(:server_path) { File.join(Dir.tmpdir,'ronin_unix_server') }
-
-      it "should create a new UNIXServer" do
-        server = subject.unix_server(server_path)
-
-        expect(server).to be_kind_of(UNIXServer)
-        expect(server).not_to be_closed
-
-        server.close
-      end
-
-      it "should yield the new UNIXServer" do
-        server = nil
-        
-        subject.unix_server(server_path) do |yielded_server|
-          server = yielded_server
-        end
-
-        expect(server).to be_kind_of(UNIXServer)
-        expect(server).not_to be_closed
-
-        server.close
-      end
-
-      after(:each) { FileUtils.rm(server_path) }
-    end
-
-    describe "#unix_server_session" do
-      let(:server_path) { File.join(Dir.tmpdir,'ronin_unix_server') }
-
-      it "should create a temporary UNIXServer" do
-        server = nil
-        
-        subject.unix_server_session(server_path) do |yielded_server|
-          server = yielded_server
-        end
-
-        expect(server).to be_kind_of(UNIXServer)
-        expect(server).to be_closed
-      end
-
-      after(:each) { FileUtils.rm(server_path) }
-    end
-
-    describe "#unix_accept" do
-      pending "need to automate connecting to the UNIXServer"
-    end
-  end
-end

data/spec/path_spec.rb

@@ -1,111 +0,0 @@
-require 'spec_helper'
-require 'ronin/path'
-
-describe Path do
-  subject { described_class }
-
-  let(:n) { 7 }
-
-  it "should inherit from Pathname" do
-    expect(subject.superclass).to eq(Pathname)
-  end
-
-  describe "#initialize" do
-    it "should accept a separator argument" do
-      path = described_class.new('foo',"\\")
-
-      expect(path.separator).to eq("\\")
-    end
-
-    it "should default the separator to File::SEPARATOR" do
-      path = described_class.new('foo')
-
-      expect(path.separator).to eq(File::SEPARATOR)
-    end
-  end
-
-  describe "up" do
-    it "should be able to traverse up 0 directories" do
-      expect(subject.up(0)).to eq(File::SEPARATOR)
-    end
-
-    it "should raise an ArgumentError when not passed an Integer or Enumerable" do
-      expect {
-        subject.up(1.5)
-      }.to raise_error(ArgumentError)
-    end
-
-    it "should raise an ArgumentError on negative number of directories" do
-      expect {
-        subject.up(-1)
-      }.to raise_error(ArgumentError)
-    end
-
-    it "should create directory-escaping paths" do
-      expect(subject.up(n).to_s).to eq((['..'] * n).join(File::SEPARATOR))
-    end
-
-    it "should create a range of directory-escaping paths" do
-      range = 7..10
-
-      expect(subject.up(range)).to eq(range.map { |i| Path.up(i) })
-    end
-
-    it "should allow using custom path separators" do
-      expect(subject.up(n,'\\').to_s).to eq((['..'] * n).join("\\"))
-    end
-  end
-
-  describe "#join" do
-    subject { Path.new('base') }
-
-    it "should join with sub-paths" do
-      sub_path = File.join('one','two')
-      expected = [subject, sub_path].join(File::SEPARATOR)
-
-      expect(subject.join(sub_path).to_s).to eq(expected)
-    end
-
-    it "should join with a sub-directory" do
-      sub_directory = 'three'
-      expected = [subject, sub_directory].join(File::SEPARATOR)
-
-      expect(subject.join(sub_directory).to_s).to eq(expected)
-    end
-
-    it "should not collapse directory traversals" do
-      traversal = Path.up(n)
-      expected = [subject, traversal].join(File::SEPARATOR)
-
-      expect(subject.join(traversal).to_s).to eq(expected)
-    end
-
-    it "should filter out leading directory separators" do
-      expected = [subject, 'sub'].join(File::SEPARATOR)
-
-      expect(subject.join('/','sub','/').to_s).to eq(expected)
-    end
-
-    it "should filter out extra directory separators" do
-      expected = [subject, 'sub'].join(File::SEPARATOR)
-
-      expect(subject.join('/sub').to_s).to eq(expected)
-    end
-
-    it "should join with the root path" do
-      expect(Path.root.join('etc','passwd').to_s).to eq('/etc/passwd')
-    end
-
-    context "with a custom path seperator" do
-      let(:separator) { "\\" }
-
-      subject { described_class.new('foo',separator) }
-
-      it "should pass the path separator to the new path" do
-        new_path = subject.join('bar','baz')
-
-        expect(new_path.separator).to eq(separator)
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,8 +0,0 @@
-require 'rspec'
-require 'ronin/support/version'
-
-include Ronin
-
-RSpec.configure do |specs|
-  specs.filter_run_excluding :network
-end

data/spec/support/inflector_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'ronin/support/inflector'
-
-describe "Ronin::Support::Inflector" do
-  subject { Ronin::Support::Inflector }
-
-  it "should not be nil" do
-    expect(subject).not_to be_nil
-  end
-
-  it "should support pluralizing words" do
-    expect(subject.pluralize('word')).to eq('words')
-  end
-
-  it "should support singularizing words" do
-    expect(subject.singularize('words')).to eq('word')
-  end
-
-  it "should support humanizing words" do
-    expect(subject.humanize('word_id')).to eq('Word')
-  end
-end

data/spec/support_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-require 'ronin/support/version'
-
-describe Support do
-  it "should have a version" do
-    expect(subject.const_defined?('VERSION')).to be(true)
-  end
-end

data/spec/templates/classes/example_erb.rb

@@ -1,11 +0,0 @@
-require 'ronin/templates/erb'
-
-class ExampleErb
-
-  include Ronin::Templates::Erb
-
-  attr_accessor :x
-
-  attr_accessor :y
-
-end

data/spec/templates/classes/example_template.rb

@@ -1,35 +0,0 @@
-require 'ronin/templates/template'
-
-class ExampleTemplate
-
-  include Ronin::Templates::Template
-
-  def enter_example_template(&block)
-    enter_template(File.join('templates','example.erb'),&block)
-  end
-
-  def enter_relative_template(&block)
-    enter_template(File.join('templates','example.erb')) do |path|
-      enter_template(File.join('..','includes','_relative.erb'),&block)
-    end
-  end
-
-  def enter_missing_template(&block)
-    enter_template('totally_missing.erb',&block)
-  end
-
-  def read_example_template(&block)
-    read_template(File.join('templates','example.erb'),&block)
-  end
-
-  def read_relative_template(&block)
-    read_template(File.join('templates','example.erb')) do |contents|
-      read_template(File.join('..','includes','_relative.erb'),&block)
-    end
-  end
-
-  def read_missing_template(&block)
-    read_template('totally_missing.erb',&block)
-  end
-
-end

data/spec/templates/erb_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'ronin/templates/erb'
-
-require 'templates/classes/example_erb'
-
-describe Templates::Erb do
-  subject { ExampleErb.new }
-
-  before do
-    subject.x = 2
-    subject.y = 3
-  end
-
-  it "should render inline ERB templates" do
-    expect(subject.erb(%{<%= 'hello' %>})).to eq('hello')
-  end
-
-  it "should render ERB templates using the binding of the object" do
-    expect(subject.erb(%{<%= @x %> <%= @y %>})).to eq('2 3')
-  end
-end

data/spec/templates/helpers/data/includes/_relative.erb

@@ -1 +0,0 @@
-This is a template that will be called using a relative path.

data/spec/templates/helpers/data/templates/example.erb

@@ -1 +0,0 @@
-Example template.

data/spec/templates/helpers/data.rb

@@ -1,9 +0,0 @@
-require 'data_paths'
-
-module Helpers
-  include DataPaths
-
-  TEMPLATE_DIR = File.expand_path(File.join(File.dirname(__FILE__),'data'))
-
-  register_data_path TEMPLATE_DIR
-end

data/spec/templates/template_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'ronin/templates/template'
-
-require 'templates/classes/example_template'
-require 'templates/helpers/data'
-
-describe Templates::Template do
-  let(:example_template) { File.join(Helpers::TEMPLATE_DIR,'templates','example.erb') }
-  let(:relative_template) { File.join(Helpers::TEMPLATE_DIR,'includes','_relative.erb') }
-
-  subject { ExampleTemplate.new }
-
-  it "should return the result of the block when entering a template" do
-    expect(subject.enter_example_template { |path|
-      'result'
-    }).to eq('result')
-  end
-
-  it "should be able to find templates relative to the current one" do
-    subject.enter_example_template do |path|
-      expect(path).to eq(example_template)
-    end
-  end
-
-  it "should be able to find static templates" do
-    subject.enter_relative_template do |path|
-      expect(path).to eq(relative_template)
-    end
-  end
-
-  it "should raise a RuntimeError when entering an unknown template" do
-    expect {
-      subject.enter_missing_template { |path| }
-    }.to raise_error(RuntimeError)
-  end
-
-  it "should be able to read templates relative to the current one" do
-    subject.read_example_template do |contents|
-      expect(contents).to eq(File.read(example_template))
-    end
-  end
-
-  it "should be able to find static templates" do
-    subject.read_relative_template do |contents|
-      expect(contents).to eq(File.read(relative_template))
-    end
-  end
-
-  it "should raise a RuntimeError when entering an unknown template" do
-    expect {
-      subject.read_missing_template { |path| }
-    }.to raise_error(RuntimeError)
-  end
-end

data/spec/ui/classes/test_shell.rb

@@ -1,22 +0,0 @@
-require 'ronin/ui/shell'
-
-class TestShell < Ronin::UI::Shell
-
-  def a_public_method
-  end
-
-  protected
-
-  def command1
-    :command1
-  end
-
-  def command_with_arg(arg)
-    arg
-  end
-
-  def command_with_args(*args)
-    args
-  end
-
-end

data/spec/ui/output_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-require 'ronin/ui/output'
-
-describe UI::Output do
-  it "should be quiet by default" do
-    should be_quiet
-  end
-
-  it "may become verbose" do
-    subject.verbose!
-
-    should be_verbose
-    should_not be_quiet
-    should_not be_silent
-  end
-
-  it "may become quiet" do
-    subject.quiet!
-
-    should be_quiet
-    should_not be_silent
-    should_not be_verbose
-  end
-
-  it "may become silent" do
-    subject.silent!
-
-    should be_silent
-    should_not be_quiet
-    should_not be_verbose
-  end
-end

data/spec/ui/shell_spec.rb

@@ -1,83 +0,0 @@
-require 'spec_helper'
-require 'ronin/ui/shell'
-
-require 'ui/classes/test_shell'
-
-describe UI::Shell do
-  context "with handler callback" do
-    let(:line) { 'one two three' }
-
-    it "should call the input handler with the shell and input line" do
-      lines = []
-      shell = described_class.new { |shell,input| lines << input }
-
-      shell.call(line)
-
-      expect(lines).to eq([line])
-    end
-  end
-
-  context "with commands" do
-    subject { TestShell.new }
-
-    describe "#commands" do
-      it "should include builtin methods" do
-        expect(subject.commands).to include('help', 'exit')
-      end
-
-      it "should include protected methods" do
-        expect(subject.commands).to include(
-          'command1',
-          'command_with_arg',
-          'command_with_args'
-        )
-      end
-
-      it "should not include public methods" do
-        expect(subject.commands).not_to include('a_public_method')
-      end
-    end
-
-    describe "#call" do
-      it "should ignore empty lines" do
-        expect(subject.call('')).to be(false)
-      end
-
-      it "should ignore white-space lines" do
-        expect(subject.call("     \t   ")).to be(false)
-      end
-
-      it "should not allow calling the handler method" do
-        expect(subject.call('handler')).to be(false)
-      end
-
-      it "should not allow calling unknown commands" do
-        expect(subject.call('an_unknown_command')).to be(false)
-      end
-
-      it "should not allow calling unknown commands" do
-        expect(subject.call('an_unknown_command')).to be(false)
-      end
-
-      it "should not allow calling public methods" do
-        expect(subject.call('a_public_method')).to be(false)
-      end
-
-      it "should allow calling protected methods" do
-        expect(subject.call('command1')).to eq(:command1)
-      end
-
-      it "should raise an exception when passing invalid number of arguments" do
-        expect {
-          subject.call('command_with_arg too many args')
-        }.to raise_error(ArgumentError)
-      end
-
-      it "should splat the command arguments to the command method" do
-        expect(subject.call('command_with_args one two three')).to eq([
-          'one', 'two', 'three'
-        ])
-      end
-    end
-  end
-end