ronin-post_ex 0.1.0.beta1 → 0.1.0

data/spec/sessions/rpc_session_spec.rb

@@ -1,500 +0,0 @@
-require 'spec_helper'
-require 'ronin/post_ex/sessions/rpc_session'
-
-describe Ronin::PostEx::Sessions::RPCSession do
-  let(:rpc_client) { double('RPC Client') }
-
-  subject { described_class.new(rpc_client) }
-
-  describe "#initialize" do
-    it "must set #client" do
-      expect(subject.client).to be(rpc_client)
-    end
-  end
-
-  let(:response) { double('response value') }
-
-  describe "#sys_time" do
-    it "must call 'sys.time'" do
-      expect(rpc_client).to receive(:call).with('sys.time').and_return(response)
-
-      expect(subject.sys_time).to be(response)
-    end
-  end
-
-  describe "#sys_hostname" do
-    it "must call 'sys.time'" do
-      expect(rpc_client).to receive(:call).with('sys.hostname').and_return(response)
-
-      expect(subject.sys_hostname).to be(response)
-    end
-  end
-
-  describe "#file_open" do
-    let(:path) { '/path/to/file' }
-
-    it "must call 'file.open' with a path and 'r' arguments" do
-      expect(rpc_client).to receive(:call).with('file.open',path,'r').and_return(response)
-
-      expect(subject.file_open(path)).to be(response)
-    end
-
-    context "when given the additional mode argument" do
-      let(:mode) { 'rb' }
-
-      it "must call 'file.open' with a path and mode arguments" do
-        expect(rpc_client).to receive(:call).with('file.open',path,mode).and_return(response)
-
-        expect(subject.file_open(path,mode)).to be(response)
-      end
-    end
-  end
-
-  describe "#file_read" do
-    let(:fd)     { double('fd')     }
-    let(:length) { double('length') }
-
-    it "must call 'file.read' with a length arguments" do
-      expect(rpc_client).to receive(:call).with('file.read',fd,length).and_return(response)
-
-      expect(subject.file_read(fd,length)).to be(response)
-    end
-  end
-
-  describe "#file_write" do
-    let(:fd)   { double('fd')   }
-    let(:pos)  { double('pos')  }
-    let(:data) { double('data') }
-
-    it "must call 'file.read' with fd, pos, and data arguments" do
-      expect(rpc_client).to receive(:call).with('file.write',fd,pos,data).and_return(response)
-
-      expect(subject.file_write(fd,pos,data)).to be(response)
-    end
-  end
-
-  describe "#file_seek" do
-    let(:fd)      { double('fd')      }
-    let(:new_pos) { double('new_pos') }
-    let(:whence)  { double('whence')  }
-
-    it "must call 'file.seek' with fd, new_pos, and whence arguments" do
-      expect(rpc_client).to receive(:call).with('file.seek',fd,new_pos,whence).and_return(response)
-
-      expect(subject.file_seek(fd,new_pos,whence)).to be(response)
-    end
-  end
-
-  describe "#file_tell" do
-    let(:fd) { double('fd') }
-
-    it "must call 'file.seek' with a fd argument" do
-      expect(rpc_client).to receive(:call).with('file.tell',fd).and_return(response)
-
-      expect(subject.file_tell(fd)).to be(response)
-    end
-  end
-
-  describe "#file_ioctl" do
-    let(:fd)       { double('fd')       }
-    let(:command)  { double('command')  }
-    let(:argument) { double('argument') }
-
-    it "must call 'file.ioctl' with a fd, command, and 'argument' arguments" do
-      expect(rpc_client).to receive(:call).with('file.ioctl',fd,command,argument).and_return(response)
-
-      expect(subject.file_ioctl(fd,command,argument)).to be(response)
-    end
-  end
-
-  describe "#file_fcntl" do
-    let(:fd)       { double('fd')       }
-    let(:command)  { double('command')  }
-    let(:argument) { double('argument') }
-
-    it "must call 'file.fcntl' with a fd, command, and 'argument' arguments" do
-      expect(rpc_client).to receive(:call).with('file.fcntl',fd,command,argument).and_return(response)
-
-      expect(subject.file_fcntl(fd,command,argument)).to be(response)
-    end
-  end
-
-  describe "#file_stat" do
-    let(:fd) { double('fd') }
-
-    it "must call 'file.stat' with a fd argument" do
-      expect(rpc_client).to receive(:call).with('file.stat',fd).and_return(response)
-
-      expect(subject.file_stat(fd)).to be(response)
-    end
-  end
-
-  describe "#file_close" do
-    let(:fd) { double('fd') }
-
-    it "must call 'file.fcntl' with a fd argument" do
-      expect(rpc_client).to receive(:call).with('file.close',fd).and_return(response)
-
-      expect(subject.file_close(fd)).to be(response)
-    end
-  end
-
-  describe "#fs_gtecwd" do
-    it "must call 'fs.getcwd'" do
-      expect(rpc_client).to receive(:call).with('fs.getcwd').and_return(response)
-
-      expect(subject.fs_getcwd).to be(response)
-    end
-  end
-
-  describe "#fs_chdir" do
-    let(:path) { double('path') }
-
-    it "must call 'fs.chdir' with a path argument" do
-      expect(rpc_client).to receive(:call).with('fs.chdir',path).and_return(response)
-
-      expect(subject.fs_chdir(path)).to be(response)
-    end
-  end
-
-  describe "#fs_readfile" do
-    let(:path) { double('path') }
-
-    it "must call 'fs.readfile' with a path argument" do
-      expect(rpc_client).to receive(:call).with('fs.readfile',path).and_return(response)
-
-      expect(subject.fs_readfile(path)).to be(response)
-    end
-  end
-
-  describe "#fs_readlink" do
-    let(:path) { double('path') }
-
-    it "must call 'fs.readlink' with a path argument" do
-      expect(rpc_client).to receive(:call).with('fs.readlink',path).and_return(response)
-
-      expect(subject.fs_readlink(path)).to be(response)
-    end
-  end
-
-  describe "#fs_readdir" do
-    let(:path) { double('path') }
-
-    it "must call 'fs.readdir' with a path argument" do
-      expect(rpc_client).to receive(:call).with('fs.readdir',path).and_return(response)
-
-      expect(subject.fs_readdir(path)).to be(response)
-    end
-  end
-
-  describe "#fs_glob" do
-    let(:pattern) { double('pattern') }
-
-    it "must call 'fs.glob' with a pattern argument" do
-      expect(rpc_client).to receive(:call).with('fs.glob',pattern).and_return(response)
-
-      expect(subject.fs_glob(pattern)).to be(response)
-    end
-  end
-
-  describe "#fs_mktemp" do
-    let(:basename) { double('basename') }
-
-    it "must call 'fs.mktemp' with a basename argument" do
-      expect(rpc_client).to receive(:call).with('fs.mktemp',basename).and_return(response)
-
-      expect(subject.fs_mktemp(basename)).to be(response)
-    end
-  end
-
-  describe "#fs_mkdir" do
-    let(:new_path) { double('new_path') }
-
-    it "must call 'fs.mkdir' with a new_path argument" do
-      expect(rpc_client).to receive(:call).with('fs.mkdir',new_path).and_return(response)
-
-      expect(subject.fs_mkdir(new_path)).to be(response)
-    end
-  end
-
-  describe "#fs_copy" do
-    let(:src)  { double('src')  }
-    let(:dest) { double('dest') }
-
-    it "must call 'fs.copy' with src and dest arguments" do
-      expect(rpc_client).to receive(:call).with('fs.copy',src,dest).and_return(response)
-
-      expect(subject.fs_copy(src,dest)).to be(response)
-    end
-  end
-
-  describe "#fs_unlink" do
-    let(:path)  { double('path') }
-
-    it "must call 'fs.unlink' with a path arguments" do
-      expect(rpc_client).to receive(:call).with('fs.unlink',path).and_return(response)
-
-      expect(subject.fs_unlink(path)).to be(response)
-    end
-  end
-
-  describe "#fs_rmdir" do
-    let(:path)  { double('path') }
-
-    it "must call 'fs.rmdir' with a path arguments" do
-      expect(rpc_client).to receive(:call).with('fs.rmdir',path).and_return(response)
-
-      expect(subject.fs_rmdir(path)).to be(response)
-    end
-  end
-
-  describe "#fs_move" do
-    let(:src)  { double('src')  }
-    let(:dest) { double('dest') }
-
-    it "must call 'fs.move' with src and dest arguments" do
-      expect(rpc_client).to receive(:call).with('fs.move',src,dest).and_return(response)
-
-      expect(subject.fs_move(src,dest)).to be(response)
-    end
-  end
-
-  describe "#fs_link" do
-    let(:src)  { double('src')  }
-    let(:dest) { double('dest') }
-
-    it "must call 'fs.link' with src and dest arguments" do
-      expect(rpc_client).to receive(:call).with('fs.link',src,dest).and_return(response)
-
-      expect(subject.fs_link(src,dest)).to be(response)
-    end
-  end
-
-  describe "#fs_chgrp" do
-    let(:group) { double('group') }
-    let(:path)  { double('path')  }
-
-    it "must call 'fs.chgrp' with group and path arguments" do
-      expect(rpc_client).to receive(:call).with('fs.chgrp',group,path).and_return(response)
-
-      expect(subject.fs_chgrp(group,path)).to be(response)
-    end
-  end
-
-  describe "#fs_chown" do
-    let(:user) { double('user') }
-    let(:path) { double('path') }
-
-    it "must call 'fs.chown' with user and path arguments" do
-      expect(rpc_client).to receive(:call).with('fs.chown',user,path).and_return(response)
-
-      expect(subject.fs_chown(user,path)).to be(response)
-    end
-  end
-
-  describe "#fs_chmod" do
-    let(:mode) { double('mode') }
-    let(:path) { double('path') }
-
-    it "must call 'fs.chmod' with mode and path arguments" do
-      expect(rpc_client).to receive(:call).with('fs.chmod',mode,path).and_return(response)
-
-      expect(subject.fs_chmod(mode,path)).to be(response)
-    end
-  end
-
-  describe "#fs_stat" do
-    let(:path) { double('path') }
-
-    it "must call 'fs.stat' with a path argument" do
-      expect(rpc_client).to receive(:call).with('fs.stat',path).and_return(response)
-
-      expect(subject.fs_stat(path)).to be(response)
-    end
-  end
-
-  describe "#process_getpid" do
-    it "must call 'process.getpid'" do
-      expect(rpc_client).to receive(:call).with('process.getpid').and_return(response)
-
-      expect(subject.process_getpid).to be(response)
-    end
-  end
-
-  describe "#process_getppid" do
-    it "must call 'process.getppid'" do
-      expect(rpc_client).to receive(:call).with('process.getppid').and_return(response)
-
-      expect(subject.process_getppid).to be(response)
-    end
-  end
-
-  describe "#process_getuid" do
-    it "must call 'process.getuid'" do
-      expect(rpc_client).to receive(:call).with('process.getuid').and_return(response)
-
-      expect(subject.process_getuid).to be(response)
-    end
-  end
-
-  describe "#process_setuid" do
-    let(:uid) { double('uid') }
-
-    it "must call 'process.setuid' with a uid argument" do
-      expect(rpc_client).to receive(:call).with('process.setuid',uid).and_return(response)
-
-      expect(subject.process_setuid(uid)).to be(response)
-    end
-  end
-
-  describe "#process_geteuid" do
-    it "must call 'process.geteuid'" do
-      expect(rpc_client).to receive(:call).with('process.geteuid').and_return(response)
-
-      expect(subject.process_geteuid).to be(response)
-    end
-  end
-
-  describe "#process_seteuid" do
-    let(:euid) { double('euid') }
-
-    it "must call 'process.seteuid' with a euid argument" do
-      expect(rpc_client).to receive(:call).with('process.seteuid',euid).and_return(response)
-
-      expect(subject.process_seteuid(euid)).to be(response)
-    end
-  end
-
-  describe "#process_getgid" do
-    it "must call 'process.getgid'" do
-      expect(rpc_client).to receive(:call).with('process.getgid').and_return(response)
-
-      expect(subject.process_getgid).to be(response)
-    end
-  end
-
-  describe "#process_setgid" do
-    let(:gid) { double('gid') }
-
-    it "must call 'process.setgid' with a gid argument" do
-      expect(rpc_client).to receive(:call).with('process.setgid',gid).and_return(response)
-
-      expect(subject.process_setgid(gid)).to be(response)
-    end
-  end
-
-  describe "#process_getegid" do
-    it "must call 'process.getegid'" do
-      expect(rpc_client).to receive(:call).with('process.getegid').and_return(response)
-
-      expect(subject.process_getegid).to be(response)
-    end
-  end
-
-  describe "#process_setegid" do
-    let(:egid) { double('egid') }
-
-    it "must call 'process.setegid' with a egid argument" do
-      expect(rpc_client).to receive(:call).with('process.setegid',egid).and_return(response)
-
-      expect(subject.process_setegid(egid)).to be(response)
-    end
-  end
-
-  describe "#process_getsid" do
-    it "must call 'process.getsid'" do
-      expect(rpc_client).to receive(:call).with('process.getsid').and_return(response)
-
-      expect(subject.process_getsid).to be(response)
-    end
-  end
-
-  describe "#process_setsid" do
-    let(:sid) { double('sid') }
-
-    it "must call 'process.setsid' with a sid argument" do
-      expect(rpc_client).to receive(:call).with('process.setsid',sid).and_return(response)
-
-      expect(subject.process_setsid(sid)).to be(response)
-    end
-  end
-
-  describe "#process_environ" do
-    it "must call 'process.environ'" do
-      expect(rpc_client).to receive(:call).with('process.environ').and_return(response)
-
-      expect(subject.process_environ).to be(response)
-    end
-  end
-
-  describe "#process_getenv" do
-    let(:name) { double('name') }
-
-    it "must call 'process.getenv' with a name argument" do
-      expect(rpc_client).to receive(:call).with('process.getenv',name).and_return(response)
-
-      expect(subject.process_getenv(name)).to be(response)
-    end
-  end
-
-  describe "#process_getenv" do
-    let(:name)  { double('name')  }
-    let(:value) { double('value') }
-
-    it "must call 'process.setenv' with name and value arguments" do
-      expect(rpc_client).to receive(:call).with('process.setenv',name,value).and_return(response)
-
-      expect(subject.process_setenv(name,value)).to be(response)
-    end
-  end
-
-  describe "#process_unsetenv" do
-    let(:name) { double('name') }
-
-    it "must call 'process.unsetenv' with a name argument" do
-      expect(rpc_client).to receive(:call).with('process.unsetenv',name).and_return(response)
-
-      expect(subject.process_unsetenv(name)).to be(response)
-    end
-  end
-
-  describe "#process_kill" do
-    let(:pid)    { double('pid')    }
-    let(:signal) { double('signal') }
-
-    it "must call 'process.kill' with pid and signal arguments" do
-      expect(rpc_client).to receive(:call).with('process.kill',pid,signal).and_return(response)
-
-      expect(subject.process_kill(pid,signal)).to be(response)
-    end
-  end
-
-  describe "#process_spawn" do
-    let(:program)   { double('program') }
-    let(:arguments) { [double('arg1'), double('arg2')] }
-
-    it "must call 'process.spawn' with program and 'arguments' arguments" do
-      expect(rpc_client).to receive(:call).with('process.spawn',program,*arguments).and_return(response)
-
-      expect(subject.process_spawn(program,*arguments)).to be(response)
-    end
-  end
-
-  describe "#process_exit" do
-    it "must call 'process.exit'" do
-      expect(rpc_client).to receive(:call).with('process.exit').and_return(response)
-
-      expect(subject.process_exit).to be(response)
-    end
-  end
-
-  describe "#shell_exec" do
-    let(:command) { double('command') }
-
-    it "must call 'shell.exec' with a command argument" do
-      expect(rpc_client).to receive(:call).with('shell.exec',command).and_return(response)
-
-      expect(subject.shell_exec(command)).to be(response)
-    end
-  end
-end

data/spec/sessions/session_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-require 'ronin/post_ex/sessions/session'
-
-describe Ronin::PostEx::Sessions::Session do
-  describe "#name" do
-    context "when #name is set" do
-      module TestSession
-        class SessionWithNameSet < Ronin::PostEx::Sessions::Session
-
-          def initialize(name)
-            @name = name
-          end
-
-        end
-      end
-
-      let(:name) { 'example-session' }
-
-      subject { TestSession::SessionWithNameSet.new(name) }
-
-      it "must return @name" do
-        expect(subject.name).to eq(name)
-      end
-    end
-
-    context "when @name is not set" do
-      module TestSession
-        class SessionWithoutNameSet < Ronin::PostEx::Sessions::Session
-        end
-      end
-
-      subject { TestSession::SessionWithoutNameSet.new }
-
-      it do
-        expect {
-          subject.name
-        }.to raise_error(NotImplementedError,"#{subject.class}#name was not set")
-      end
-    end
-  end
-
-  describe "#system" do
-    it "must return a Ronin::PostEx::System object" do
-      expect(subject.system).to be_kind_of(Ronin::PostEx::System)
-    end
-
-    it "must return the same object each time" do
-      expect(subject.system).to be(subject.system)
-    end
-  end
-
-  describe "#to_s" do
-    let(:name) { "host:port" }
-
-    it "must call #name" do
-      expect(subject).to receive(:name).and_return(name)
-
-      expect(subject.to_s).to be(name)
-    end
-  end
-end