ronin 0.2.3 → 0.2.4

data/spec/extensions/string_spec.rb

@@ -96,4 +96,8 @@ describe String do
   it "should dump strings containing non-printable characters" do
     "hello\x90\x05\xef".dump.should == '"hello\x90\x05\xef"'
   end
+
+  it "should dump the string when calling the inspect method" do
+    "hello\x90\x05\xef".inspect.should == '"hello\x90\x05\xef"'
+  end
 end

data/spec/formatting/binary/integer_spec.rb

@@ -4,15 +4,15 @@ require 'spec_helper'
 
 describe Integer do
   it "should provide Integer#bytes" do
-    Integer.instance_method('bytes').should_not be_nil
+    Integer.method_defined?(:bytes).should == true
   end
 
   it "should provide Integer#pack" do
-    Integer.instance_method('pack').should_not be_nil
+    Integer.method_defined?(:pack).should == true
   end
 
   it "should provide Integer#hex_escape" do
-    Integer.instance_method('hex_escape').should_not be_nil
+    Integer.method_defined?(:hex_escape).should == true
   end
 
   describe "bytes" do

data/spec/formatting/binary/string_spec.rb

@@ -5,23 +5,23 @@ require 'formatting/binary/helpers/hexdumps'
 
 describe String do
   it "should provide String#depack" do
-    String.instance_method('depack').should_not be_nil
+    String.method_defined?(:depack).should == true
   end
 
   it "should provide String#hex_escape" do
-    String.instance_method('hex_escape').should_not be_nil
+    String.method_defined?(:hex_escape).should == true
   end
 
   it "should provide String#hex_unescape" do
-    String.instance_method('hex_unescape').should_not be_nil
+    String.method_defined?(:hex_unescape).should == true
   end
 
   it "should provide String#xor" do
-    String.instance_method('xor').should_not be_nil
+    String.method_defined?(:xor).should == true
   end
 
   it "should provide String#unhexdump" do
-    String.instance_method('unhexdump').should_not be_nil
+    String.method_defined?(:unhexdump).should == true
   end
 
   describe "depack" do

data/spec/formatting/digest/string_spec.rb

@@ -3,28 +3,24 @@ require 'ronin/formatting/digest'
 require 'spec_helper'
 
 describe String do
-  before(:all) do
-    @string = "test"
-  end
-
   it "should provide String#md5" do
-    @string.respond_to?('md5').should == true
+    String.method_defined?(:md5).should == true
   end
 
   it "should provide String#sha1" do
-    @string.respond_to?('sha1').should == true
+    String.method_defined?(:sha1).should == true
   end
 
   it "should provide String#sha2" do
-    @string.respond_to?('sha2').should == true
+    String.method_defined?(:sha2).should == true
   end
 
   it "should provide String#sha256" do
-    @string.respond_to?('sha256').should == true
+    String.method_defined?(:sha256).should == true
   end
 
   it "should provide String#sha512" do
-    @string.respond_to?('sha512').should == true
+    String.method_defined?(:sha512).should == true
   end
 
   describe "md5" do

data/spec/formatting/http/string_spec.rb

@@ -3,28 +3,24 @@ require 'ronin/formatting/http'
 require 'spec_helper'
 
 describe String do
-  before(:all) do
-    @string = "mod % 3"
-  end
-
   it "should provide String#uri_encode" do
-    @string.respond_to?('uri_encode').should == true
+    String.method_defined?(:uri_encode).should == true
   end
 
   it "should provide String#uri_decode" do
-    @string.respond_to?('uri_decode').should == true
+    String.method_defined?(:uri_decode).should == true
   end
 
   it "should provide String#uri_escape" do
-    @string.respond_to?('uri_escape').should == true
+    String.method_defined?(:uri_escape).should == true
   end
 
   it "should provide String#uri_unescape" do
-    @string.respond_to?('uri_unescape').should == true
+    String.method_defined?(:uri_unescape).should == true
   end
 
   it "should provide String#format_http" do
-    @string.respond_to?('format_http').should == true
+    String.method_defined?(:format_http).should == true
   end
 
   describe "uri_encode" do

data/spec/formatting/text/array_spec.rb

@@ -0,0 +1,64 @@
+require 'ronin/formatting/text'
+
+describe Array do
+  before(:all) do
+    @byte_array = [0x41, 0x41, 0x20]
+    @char_array = ['A', 'A', ' ']
+    @mixed_array = ['AA', 0x20]
+    @string = 'AA '
+  end
+
+  it "should provide Array#bytes" do
+    Array.method_defined?(:bytes).should == true
+  end
+
+  it "should provide Array#chars" do
+    Array.method_defined?(:chars).should == true
+  end
+
+  it "should provide Array#char_string" do
+    Array.method_defined?(:char_string).should == true
+  end
+
+  describe "bytes" do
+    it "should convert an Array of bytes to an Array of bytes" do
+      @byte_array.bytes.should == @byte_array
+    end
+
+    it "should convert an Array of chars to an Array of bytes" do
+      @char_array.bytes.should == @byte_array
+    end
+
+    it "should safely handle mixed byte/char/string Arrays" do
+      @mixed_array.bytes.should == @byte_array
+    end
+  end
+
+  describe "chars" do
+    it "should convert an Array of bytes to an Array of chars" do
+      @byte_array.chars.should == @char_array
+    end
+
+    it "should safely convert an Array of chars to an Array of chars" do
+      @char_array.chars.should == @char_array
+    end
+
+    it "should safely handle mixed byte/char/string Arrays" do
+      @mixed_array.chars.should == @char_array
+    end
+  end
+
+  describe "char_string" do
+    it "should convert an Array of bytes to a String" do
+      @byte_array.char_string.should == @string
+    end
+
+    it "should convert an Array of chars to a String" do
+      @char_array.char_string.should == @string
+    end
+
+    it "should safely handle mixed byte/char/string Arrays" do
+      @mixed_array.char_string.should == @string
+    end
+  end
+end

data/spec/formatting/text/string_spec.rb

@@ -8,15 +8,15 @@ describe String do
   end
 
   it "should provide String#format_chars" do
-    @string.respond_to?('format_chars').should == true
+    String.method_defined?(:format_chars).should == true
   end
 
   it "should provide String#format_bytes" do
-    @string.respond_to?('format_bytes').should == true
+    String.method_defined?(:format_bytes).should == true
   end
 
   it "should provide String#random_case" do
-    @string.respond_to?('random_case').should == true
+    String.method_defined?(:random_case).should == true
   end
 
   describe "format_chars" do

data/spec/model/classes/licensed_model.rb

@@ -0,0 +1,12 @@
+require 'ronin/model/has_license'
+
+class LicensedModel
+
+  include Ronin::Model
+  include Ronin::Model::HasLicense
+
+  property :id, Serial
+
+  property :content, String
+
+end

data/spec/{has_license_spec.rb → model/has_license_spec.rb}

@@ -1,9 +1,9 @@
-require 'ronin/has_license'
+require 'ronin/model/has_license'
 
 require 'spec_helper'
-require 'classes/licensed_model'
+require 'model/classes/licensed_model'
 
-describe HasLicense do
+describe Model::HasLicense do
   before(:all) do
     LicensedModel.auto_migrate!
   end
@@ -11,7 +11,7 @@ describe HasLicense do
   it "should have a license" do
     model = LicensedModel.new(:content => 'bla')
     model.license = License.gpl_2
-    model.save!
+    model.save
 
     model.license.should == License.gpl_2
   end
@@ -19,7 +19,7 @@ describe HasLicense do
   it "should provide helper methods for querying licensed models" do
     model = LicensedModel.new(:content => 'stuff here')
     model.license = License.gpl_2
-    model.save!
+    model.save
     model.reload
 
     LicensedModel.all(

data/spec/network/http_spec.rb

@@ -0,0 +1,197 @@
+require 'ronin/network/http'
+
+require 'spec_helper'
+
+describe Network::HTTP do
+  describe "HTTP.expand_options" do
+    it "should added a default port and path" do
+      options = {:host => 'example.com'}
+      expanded_options = Network::HTTP.expand_options(options)
+
+      expanded_options[:port].should == 80
+      expanded_options[:path].should == '/'
+    end
+
+    it "should add the default proxy settings" do
+      options = {:host => 'example.com'}
+      expanded_options = Network::HTTP.expand_options(options)
+
+      expanded_options[:proxy].should == Network::HTTP.proxy
+    end
+
+    it "should expand the :url option" do
+      options = {:url => 'http://joe:secret@example.com:8080/bla?var'}
+      expanded_options = Network::HTTP.expand_options(options)
+
+      expanded_options[:url].should be_nil
+      expanded_options[:host].should == 'example.com'
+      expanded_options[:port].should == 8080
+      expanded_options[:user].should == 'joe'
+      expanded_options[:password].should == 'secret'
+      expanded_options[:path].should == '/bla?var'
+    end
+
+    it "should add a default :path option for :url options" do
+      options = {:url => 'http://example.com'}
+      expanded_options = Network::HTTP.expand_options(options)
+
+      expanded_options[:path].should == '/'
+    end
+  end
+
+  describe "HTTP.headers" do
+    it "should convert Symbol options to HTTP Headers" do
+      options = {:user_agent => 'bla', :location => 'test'}
+
+      Network::HTTP.headers(options).should == {
+        'User-Agent' => 'bla',
+        'Location' => 'test'
+      }
+    end
+
+    it "should convert String options to HTTP Headers" do
+      options = {'user_agent' => 'bla', 'x-powered-by' => 'PHP'}
+
+      Network::HTTP.headers(options).should == {
+        'User-Agent' => 'bla',
+        'X-Powered-By' => 'PHP'
+      }
+    end
+
+    it "should convert all values to Strings" do
+      mtime = Time.now.to_i
+      options = {:modified_by => mtime, :x_accept => :gzip}
+
+      Network::HTTP.headers(options).should == {
+        'Modified-By' => mtime.to_s,
+        'X-Accept' => 'gzip'
+      }
+    end
+  end
+
+  describe "HTTP.request" do
+    it "should handle Symbol names" do
+      Network::HTTP.request(
+        :method => :get, :path => '/'
+      ).class.should == Net::HTTP::Get
+    end
+
+    it "should handle String names" do
+      Network::HTTP.request(
+        :method => 'GET', :path => '/'
+      ).class.should == Net::HTTP::Get
+    end
+
+    it "should raise an UnknownRequest exception for invalid names" do
+      lambda {
+        Network::HTTP.request(:method => :bla)
+      }.should raise_error(Network::HTTP::UnknownRequest)
+    end
+
+    it "should use a default path" do
+      lambda {
+        Network::HTTP.request(:method => :get)
+      }.should_not raise_error(ArgumentError)
+    end
+
+    it "should accept the :user option for Basic-Auth" do
+      req = Network::HTTP.request(:method => :get, :user => 'joe')
+
+      req['authorization'].should == "Basic am9lOg=="
+    end
+
+    it "should accept the :user and :password options for Basic-Auth" do
+      req = Network::HTTP.request(
+        :method => :get,
+        :user => 'joe',
+        :password => 'secret'
+      )
+
+      req['authorization'].should == "Basic am9lOnNlY3JldA=="
+    end
+
+    it "should create HTTP Copy requests" do
+      req = Network::HTTP.request(:method => :copy)
+
+      req.class.should == Net::HTTP::Copy
+    end
+
+    it "should create HTTP Delete requests" do
+      req = Network::HTTP.request(:method => :delete)
+
+      req.class.should == Net::HTTP::Delete
+    end
+
+    it "should create HTTP Get requests" do
+      req = Network::HTTP.request(:method => :get)
+
+      req.class.should == Net::HTTP::Get
+    end
+
+    it "should create HTTP Head requests" do
+      req = Network::HTTP.request(:method => :head)
+
+      req.class.should == Net::HTTP::Head
+    end
+
+    it "should create HTTP Lock requests" do
+      req = Network::HTTP.request(:method => :lock)
+
+      req.class.should == Net::HTTP::Lock
+    end
+
+    it "should create HTTP Mkcol requests" do
+      req = Network::HTTP.request(:method => :mkcol)
+
+      req.class.should == Net::HTTP::Mkcol
+    end
+
+    it "should create HTTP Move requests" do
+      req = Network::HTTP.request(:method => :move)
+
+      req.class.should == Net::HTTP::Move
+    end
+
+    it "should create HTTP Options requests" do
+      req = Network::HTTP.request(:method => :options)
+
+      req.class.should == Net::HTTP::Options
+    end
+
+    it "should create HTTP Post requests" do
+      req = Network::HTTP.request(:method => :post)
+
+      req.class.should == Net::HTTP::Post
+    end
+
+    it "should create HTTP Propfind requests" do
+      req = Network::HTTP.request(:method => :propfind)
+
+      req.class.should == Net::HTTP::Propfind
+    end
+
+    it "should create HTTP Proppatch requests" do
+      req = Network::HTTP.request(:method => :proppatch)
+
+      req.class.should == Net::HTTP::Proppatch
+    end
+
+    it "should create HTTP Trace requests" do
+      req = Network::HTTP.request(:method => :trace)
+
+      req.class.should == Net::HTTP::Trace
+    end
+
+    it "should create HTTP Unlock requests" do
+      req = Network::HTTP.request(:method => :unlock)
+
+      req.class.should == Net::HTTP::Unlock
+    end
+
+    it "should raise an ArgumentError when :method is not specified" do
+      lambda {
+        Network::HTTP.request()
+      }.should raise_error(ArgumentError)
+    end
+  end
+end