messenger 0.0.3 → 0.1.0

data/VERSION.yml

@@ -1,5 +1,5 @@
 --- 
-:patch: 3
+:patch: 0
 :major: 0
-:minor: 0
 :build: 
+:minor: 1

data/bin/messenger

@@ -61,8 +61,8 @@ EOS
   opt :jabber_password, "The password for your jabber id", :type => String
 
   # CLI options
-  opt :silent, "Don't print anything to stdout", :default => false
-  opt :verbose, "Print verbose output on success", :default => false
+  # opt :silent, "Don't print anything to stdout", :default => false
+  # opt :verbose, "Print verbose output on success", :default => false
 end
 
 options.merge!(trollop_options.reject{|k,v| v.nil?})

data/lib/messenger.rb

@@ -20,6 +20,11 @@ module Messenger
   end
 
 
+  def self.valid_url?(url)
+    service_handler = handler(url)
+    service_handler.valid_url?(url)
+  end
+
   def self.send(url, message, options={})
     service_handler = handler(url)
     SystemTimer.timeout_after(options[:timeout] || 15) do
@@ -27,6 +32,11 @@ module Messenger
     end
   end
 
+  def self.obfuscate(url)
+    service_handler = handler(url)
+    service_handler.obfuscate(url)
+  end
+
 
   def self.protocol(url)
     # TODO: More services

data/lib/messenger/campfire.rb

@@ -5,14 +5,17 @@ module Messenger
 
   class Campfire
 
+    def self.valid_url?(url)
+      !!matcher(url)
+    rescue NoMethodError
+      false
+    end
+
     # URL format:
     #     campfire://api-key:room-id@subdomain.campfirenow.com
     def self.send(url, body, options={})
-      begin
-        api_key, room, subdomain = url.match(/^campfire:\/\/([^:]+):([^@]+)@([^\.]+)/)[1,3]
-      rescue
-        raise URLError, "The URL provided is invalid"
-      end
+      raise URLError, "The URL provided is invalid" unless valid_url?(url)
+      api_key, room, subdomain = matcher(url)
       response = HTTParty.post(
         "http://#{subdomain}.campfirenow.com/room/#{room}/speak.json",
         :basic_auth => { :username => api_key, :password => "x" },
@@ -22,9 +25,19 @@ module Messenger
       [success?(response), response]
     end
 
+    def self.obfuscate(url)
+      raise URLError, "The URL provided is invalid" unless valid_url?(url)
+      api_key, room, subdomain = matcher(url)
+      "campfire://xxxx:#{room}@#{subdomain}.campfirenow.com"
+    end
+
 
   private
 
+    def self.matcher(url)
+      url.match(/^campfire:\/\/([^:]+):([^@]+)@([^\.]+).campfirenow.com/)[1,3]
+    end
+
     def self.success?(response)
       case response.code
       when 200, 201: true

data/lib/messenger/email.rb

@@ -4,6 +4,10 @@ module Messenger
 
   class Email
 
+    def self.valid_url?(url)
+      !!url.match(/mailto:[^@]+@.*/)
+    end
+
     # URL format:
     #     mailto:email@example.com
     #
@@ -11,6 +15,7 @@ module Messenger
     #     :email_from => Who the email is from
     #     :email_subject => The subject of the email
     def self.send(url, message, options={})
+      raise URLError, "The URL provided is invalid" unless valid_url?(url)
       mail = Mail.new do
             from options[:email_from]
               to url.sub(/mailto:/, '')
@@ -21,6 +26,11 @@ module Messenger
       [true, nil]
     end
 
+    def self.obfuscate(url)
+      raise URLError, "The URL provided is invalid" unless valid_url?(url)
+      url
+    end
+
   end
 
 end

data/lib/messenger/jabber.rb

@@ -4,6 +4,12 @@ module Messenger
 
   class Jabber
 
+    def self.valid_url?(url)
+      !!matcher(url)
+    rescue NoMethodError
+      false
+    end
+
     # URL format:
     #     jabber://email@example.com/server_hostname
     #
@@ -13,6 +19,7 @@ module Messenger
     #     :jabber_id => The jabber id of the sender
     #     :jabber_password => The password of the sender
     def self.send(url, body, options={})
+      raise URLError, "The URL provided is invalid" unless valid_url?(url)
       recipient, host = url.sub("jabber://", "").split("/")[0,2]
       jabber = ::Jabber::Simple.new(options[:jabber_id], options[:jabber_password], host)
       jabber.deliver(recipient, body)
@@ -25,6 +32,18 @@ module Messenger
       [status, status ? nil : "Not yet authorized"]
     end
 
+    def self.obfuscate(url)
+      raise URLError, "The URL provided is invalid" unless valid_url?(url)
+      url
+    end
+
+
+  private
+
+    def self.matcher(url)
+      url.sub("jabber://", "").match("@")
+    end
+
   end
 
 end

data/lib/messenger/web.rb

@@ -4,15 +4,34 @@ module Messenger
 
   class Web
 
+    def self.valid_url?(url)
+      !!URI.parse(url)
+    rescue URI::InvalidURIError
+      false
+    end
+
     # URL format:
     #     http://example.com
+    #     https://user:pass@example.com
     #
     # The body of the message is posted as the body of the request, not the query.
     def self.send(url, body, options={})
+      raise URLError, "The URL provided is invalid" unless self.valid_url?(url)
       response = HTTParty.post(url, options.merge(:body => body))
       [success?(response), response]
     end
 
+    def self.obfuscate(url)
+      raise URLError, "The URL provided is invalid" unless self.valid_url?(url)
+      path = URI.parse(url)
+      if path.password
+        url.sub(/#{path.password}/, 'xxxx')
+      else
+        url
+      end
+    end
+
+
   private
 
     def self.success?(response)

data/test/test_campfire.rb

@@ -13,21 +13,45 @@ module Messenger
 
       should "post a successful message" do
         HTTParty.expects(:post).with("http://subdomain.campfirenow.com/room/room/speak.json", :basic_auth => { :username => 'api', :password => 'x' }, :body => '{"message":{"body":"content"}}', :headers => { "Content-Type" => "application/json" }).returns(@success_response)
-        result = Campfire.send("campfire://api:room@subdomain.campfirewnow.com", 'content')
+        result = Campfire.send("campfire://api:room@subdomain.campfirenow.com", 'content')
         assert_equal [true, @success_response], result
       end
 
       should "post a failed message" do
         HTTParty.expects(:post).with("http://subdomain.campfirenow.com/room/room/speak.json", :basic_auth => { :username => 'api', :password => 'x' }, :body => '{"message":{"body":"content"}}', :headers => { "Content-Type" => "application/json" }).returns(@failure_response)
-        result = Campfire.send("campfire://api:room@subdomain.campfirewnow.com", 'content')
+        result = Campfire.send("campfire://api:room@subdomain.campfirenow.com", 'content')
         assert_equal [false, @failure_response], result
       end
 
-      should "raise on invalid URL" do
-        assert_raises Messenger::URLError do
-          Campfire.send("campfire://missing_room@subdomain.campfirewnow.com", 'content')
+      should "raise when sending to an invalid URL" do
+        assert_raises URLError do
+          Campfire.send("campfire://missing_room@subdomain.campfirenow.com", 'content')
         end
       end
+
+      should "obfuscate the URL" do
+        assert_equal "campfire://xxxx:1234@example.campfirenow.com", Campfire.obfuscate("campfire://asdf1234:1234@example.campfirenow.com")
+      end
+
+      should "raise when obfuscating an invalid URL" do
+        assert_raises URLError do
+          Campfire.obfuscate("campfire://missing_room@subdomain.campfirenow.com")
+        end
+      end
+    end
+
+    context "Campfire URL validation" do
+      should "return true for good URLs" do
+        assert true, Campfire.valid_url?("campfire://api_key:room@subdomain.campfirenow.com")
+      end
+
+      should "return false for bad URLs" do
+        assert_equal false, Campfire.valid_url?("campfire://!")
+        assert_equal false, Campfire.valid_url?("campfire://api_key@subdomain.campfirenow.com")
+        assert_equal false, Campfire.valid_url?("campfire://:room@subdomain.campfirenow.com")
+        assert_equal false, Campfire.valid_url?("campfire://api_key:room@subdomain")
+        assert_equal false, Campfire.valid_url?("campfire://api_key:room@campfirenow.com")
+      end
     end
 
   end

data/test/test_email.rb

@@ -20,6 +20,35 @@ module Messenger
         assert_equal "Test", Mail::TestMailer.deliveries.first.subject
         assert_equal "Test message", Mail::TestMailer.deliveries.first.body.to_s
       end
+
+      should "raise if trying to send to an invalid URL" do
+        assert_raises URLError do
+          Email.send("mailto:test", :body => "whatever", :email_from => "from_test@example.com", :email_subject => "Test")
+        end
+      end
+
+      should "obfuscate the URL" do
+        assert_equal "mailto:test@example.com", Email.obfuscate("mailto:test@example.com")
+      end
+
+      should "raise if trying obfuscate an invalid URL" do
+        assert_raises URLError do
+          Email.obfuscate("mailto:test")
+        end
+      end
+    end
+
+    context "Email notificaiton URL validation" do
+      should "return true for good URLs" do
+        assert true, Email.valid_url?("mailto:test@example.com")
+      end
+
+      should "return false for bad URLs" do
+        assert_equal false, Email.valid_url?("mailto:")
+        assert_equal false, Email.valid_url?("mailto:test")
+        assert_equal false, Email.valid_url?("mailto:@example.com")
+        assert_equal false, Email.valid_url?("mailto:example.com")
+      end
     end
 
   end

data/test/test_jabber.rb

@@ -28,6 +28,34 @@ module Messenger
         result = Jabber.send("jabber://brandon@zencoder.com", "Test message", :jabber_id => "notifier@zencoder.com", :jabber_password => "asdfasdf")
         assert_equal [false, "Not yet authorized"], result
       end
+
+      should "raise when sending to an invalid URL" do
+        assert_raises URLError do
+          Jabber.send("jabber://", :jabber_id => "asdf", :jabber_password => "asdf")
+        end
+      end
+
+      should "obfuscate the URL" do
+        assert_equal "jabber://test@example.com", Jabber.obfuscate("jabber://test@example.com")
+      end
+
+      should "raise when obfuscating an invalid URL" do
+        assert_raises URLError do
+          Jabber.obfuscate("jabber://")
+        end
+      end
+    end
+
+    context "Jabber URL validation" do
+      should "return true for good URLs" do
+        assert true, Jabber.valid_url?("jabber://test@example.com")
+      end
+
+      should "return false for bad URLs" do
+        assert_equal false, Jabber.valid_url?("jabber://!")
+        assert_equal false, Jabber.valid_url?("jabber://test")
+        assert_equal false, Jabber.valid_url?("jabber://example.com")
+      end
     end
 
   end

data/test/test_messenger.rb

@@ -4,18 +4,20 @@ module Messenger
 
   class MessengerTest < Test::Unit::TestCase
 
-    context "Protocol/Handler" do
-      should "determine the proper service" do
-        assert_equal :email, Messenger.protocol("mailto:test@example.com")
-        assert_equal :http, Messenger.protocol("http://example.com")
-        assert_equal :http, Messenger.protocol("https://example.com")
-      end
+    should "determine the proper protocol" do
+      assert_equal :email, Messenger.protocol("mailto:test@example.com")
+      assert_equal :http, Messenger.protocol("http://example.com")
+      assert_equal :http, Messenger.protocol("https://example.com")
+      assert_equal :jabber, Messenger.protocol("jabber://test@example.com")
+      assert_equal :campfire, Messenger.protocol("campfire://api_key:room_id@subdomain.campfirenow.com")
+    end
 
-      should "determine the proper notification handler given a protocol" do
-        assert_equal Email, Messenger.handler("mailto:test@example.com")
-        assert_equal Web, Messenger.handler("http://example.com")
-        assert_equal Web, Messenger.handler("https://example.com")
-      end
+    should "determine the proper notification handler given a protocol" do
+      assert_equal Email, Messenger.handler("mailto:test@example.com")
+      assert_equal Web, Messenger.handler("http://example.com")
+      assert_equal Web, Messenger.handler("https://example.com")
+      assert_equal Jabber, Messenger.handler("jabber://test@example.com")
+      assert_equal Campfire, Messenger.handler("campfire://api_key:room_id@subdomain.campfirenow.com")
     end
 
   end

data/test/test_web.rb

@@ -22,6 +22,40 @@ module Messenger
         result = Web.send("http://example.com", '{ "key": "value" }', :headers => { "Content-Type" => "application/json" })
         assert_equal [false, @failure_response], result
       end
+
+      should "raise if trying to send to an invalid URL" do
+        assert_raises URLError do
+          Web.send("http://!", :body => "whatever")
+        end
+      end
+
+      should "obfuscate the URL" do
+        assert_equal "http://example.com", Web.obfuscate("http://example.com")
+        assert_equal "http://user:xxxx@example.com", Web.obfuscate("http://user:secure_pass@example.com")
+        assert_equal "https://user:xxxx@example.com", Web.obfuscate("https://user:secure_pass@example.com")
+      end
+
+      should "raise if trying to obfuscate an invalid URL" do
+        assert_raises URLError do
+          Web.obfuscate("http://!")
+        end
+      end
+    end
+
+    context "Web notificaiton URL validation" do
+      should "return true for good URLs" do
+        assert true, Web.valid_url?("http://example.com")
+        assert true, Web.valid_url?("https://example.com")
+        assert true, Web.valid_url?("https://user@example.com")
+        assert true, Web.valid_url?("http://user:pass@example.com")
+        assert true, Web.valid_url?("https://user:#{URI.escape('!#$%^&*¢ç⎋')}@example.com")
+      end
+
+      should "return false for bad URLs" do
+        assert_equal false, Web.valid_url?("http://!")
+        assert_equal false, Web.valid_url?("http://")
+        assert_equal false, Web.valid_url?("https://")
+      end
     end
 
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: messenger
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Brandon Arbini