groem 0.0.4

data/spec/shared/dummy_server.rb

@@ -0,0 +1,198 @@
+require 'eventmachine'
+
+module Groem
+  module Dummy
+    class Server < EM::Connection
+      include Groem::Constants
+      
+      DEFAULT_HOST = 'localhost'
+      DEFAULT_PORT = 23052    # note one off to avoid port conflict
+      
+      DEFAULT_RESPONSES = { :register => ['-OK', 0],
+                            :notify => ['-OK', 0],
+                            :callback => ['CLICK', 10]
+                          }
+      
+      class << self
+        def canned_responses
+          @canned_responses ||= DEFAULT_RESPONSES.dup
+        end
+        
+        def reset_canned_responses
+          @canned_responses = nil
+        end
+        
+        def respond_to_register_with(meth, err = 0)
+          canned_responses[:register] = [meth.to_s.upcase, err.to_i]
+        end
+        
+        def respond_to_notify_with(meth, err = 0)
+          canned_responses[:notify] = [meth.to_s.upcase, err.to_i]
+        end
+        
+        def callback_with(rslt, secs)
+          canned_responses[:callback] = [rslt.to_s.upcase, secs.to_i]
+        end
+        
+        def listen(host = DEFAULT_HOST, port = DEFAULT_PORT)
+          svr = EM.start_server host, port, self
+          puts "SERVER: Dummy GNTP server listening on #{host}:#{port}"
+          canned_responses.each_pair do |k, v|
+            if k == :register || k == :notify
+              puts "    #{k.to_s.upcase} responds #{v[0]} with status #{v[1]}"
+            elsif k == :callback
+              puts "    #{k.to_s.upcase} with result #{v[0]} after #{v[1]} secs"
+            end
+          end
+          svr
+        end
+      end
+
+      def post_init
+        reset_state
+      end
+      
+      def receive_data data
+        @buffer.extract(data).each do |line|
+          update_message_state!(line)
+          @lines << line
+        end
+        receive_message @lines.join("\r\n") + "\r\n" if eof?
+      end
+      
+      protected
+      
+      def reset_state
+        @buffer = BufferedTokenizer.new("\r\n")
+        @lines = []
+        @response = nil
+        @sections_left = 0
+      end
+      
+      # Horribly kludgy but that's GNTP for you...
+      def update_message_state!(line)
+        if line[/^\s*Notifications-Count\s*:\s*(\d+)/i]
+          @sections_left += $1.to_i
+        end
+        if line[/^.+:\s*x-growl-resource:/i]
+          @sections_left += 1
+        end
+        if line.empty?
+          @sections_left -= 1
+        end
+        #puts line
+        #puts "Note: #{@sections_left} more sections"
+      end
+      
+      def eof?
+        if @lines[-1].empty? && @sections_left > 0
+          puts "SERVER: CRLFCRLF received, but expecting #{@sections_left} more sections"
+        end
+        @lines[-1].empty? && @sections_left <= 0
+      end
+      
+      def receive_message message
+        puts "SERVER: Received message"
+        klass = Class.new { include Groem::Marshal::Request }
+        raw = klass.load(message, false)
+        #puts "Parsed message:\n#{raw.inspect}"
+        prepare_responses_for(raw)
+        if @response
+          send_data @response
+          puts "SERVER: Sent response"
+        end
+      end
+      
+      def canned_responses; self.class.canned_responses; end
+      
+      def prepare_responses_for(req)
+        case req['environment']['request_method']
+        when 'REGISTER'
+          prepare_register_response_for(req, 
+                                        canned_responses[:register][0], 
+                                        canned_responses[:register][1] 
+                                       )
+        when 'NOTIFY'
+          prepare_notify_response_for(req, 
+                                      canned_responses[:notify][0],
+                                      canned_responses[:notify][1]
+                                     )
+          schedule_callback_response_for(req, 
+                                        canned_responses[:callback][0],
+                                        canned_responses[:callback][1]
+                                       ) \
+            if req['headers']['Notification-Callback-Context']
+        end
+      end
+      
+      # eventually replace with Response#dump, quick & dirty for now
+      def prepare_register_response_for(req, meth, err)
+        env, hdrs = req[ENVIRONMENT_KEY], req[HEADERS_KEY]
+        out = []
+        out << "#{env[(GNTP_PROTOCOL_KEY)]}" + 
+               "/#{env[(GNTP_VERSION_KEY)]} "+
+               "#{meth} "+
+               "#{env[(GNTP_ENCRYPTION_ID_KEY)]}"
+        out << "#{GNTP_RESPONSE_ACTION_KEY}: #{GNTP_REGISTER_METHOD}"
+        if meth == GNTP_ERROR_RESPONSE
+          out << "#{GNTP_ERROR_CODE_KEY}: #{err}"
+          out << "Error-Description: An error occurred"
+        end
+        out << nil
+        out << nil
+        out << nil
+        puts "SERVER: Prepared REGISTER response: #{meth}, #{err}"
+        @response = out.join("\r\n")
+      end
+
+      def prepare_notify_response_for(req, meth, err)
+        env, hdrs = req[ENVIRONMENT_KEY], req[HEADERS_KEY]
+        out = []
+        out << "#{env[(GNTP_PROTOCOL_KEY)]}" + 
+               "/#{env[(GNTP_VERSION_KEY)]} "+
+               "#{meth} "+
+               "#{env[(GNTP_ENCRYPTION_ID_KEY)]}"
+        out << "#{GNTP_RESPONSE_ACTION_KEY}: #{GNTP_NOTIFY_METHOD}"
+        out << "#{GNTP_NOTIFICATION_ID_KEY}: #{hdrs[(GNTP_NOTIFICATION_ID_KEY)]}"
+        if meth == GNTP_ERROR_RESPONSE
+          out << "#{GNTP_ERROR_CODE_KEY}: #{err}"
+          out << "Error-Description: An error occurred"
+        end
+        out << nil
+        out << nil
+        out << nil
+        puts "SERVER: Prepared NOTIFY response: #{meth}, #{err}"
+        @response = out.join("\r\n")
+      end
+
+      def schedule_callback_response_for(req, rslt, secs)
+        EM.add_timer(secs) do
+          msg = callback_response_for(req, rslt)
+          send_data msg
+          puts "SERVER: Sent CALLBACK response: #{rslt}"
+        end
+        puts "SERVER: Scheduled CALLBACK response in #{secs} secs: #{rslt}"
+      end
+      
+      def callback_response_for(req, rslt)
+        env, hdrs = req[ENVIRONMENT_KEY], req[HEADERS_KEY]
+        out = []
+        out << "#{env[(GNTP_PROTOCOL_KEY)]}" + 
+               "/#{env[(GNTP_VERSION_KEY)]} "+
+               "#{GNTP_CALLBACK_RESPONSE} "+
+               "#{env[(GNTP_ENCRYPTION_ID_KEY)]}"
+        out << "#{GNTP_APPLICATION_NAME_KEY}: #{hdrs[(GNTP_APPLICATION_NAME_KEY)]}"
+        out << "#{GNTP_NOTIFICATION_ID_KEY}: #{hdrs[(GNTP_NOTIFICATION_ID_KEY)]}"
+        out << "#{GNTP_NOTIFICATION_CALLBACK_RESULT_KEY}: #{rslt}"
+        out << "#{GNTP_NOTIFICATION_CALLBACK_TIMESTAMP_KEY}: #{Time.now.strftime('%Y-%m-%d %H:%M:%SZ')}"
+        out << "#{GNTP_NOTIFICATION_CALLBACK_CONTEXT_KEY}: #{hdrs[(GNTP_NOTIFICATION_CALLBACK_CONTEXT_KEY)]}"
+        out << "#{GNTP_NOTIFICATION_CALLBACK_CONTEXT_TYPE_KEY}: #{hdrs[(GNTP_NOTIFICATION_CALLBACK_CONTEXT_TYPE_KEY)]}"
+        out << nil
+        out << nil
+        out << nil
+        out.join("\r\n")
+      end
+      
+    end
+  end
+end

data/spec/shared/dummy_server_helper.rb

@@ -0,0 +1,31 @@
+
+module DummyServerHelper
+  
+  DEFAULT_PORT = Groem::Dummy::Server::DEFAULT_PORT
+  
+  def self.fork_server(opts = {})
+    fork {
+      puts '-------------- server process fork ------------------'
+      Groem::Dummy::Server.reset_canned_responses
+      if opts[:register]
+        Groem::Dummy::Server.respond_to_register_with *opts[:register]
+      end
+      if opts[:notify]
+        Groem::Dummy::Server.respond_to_notify_with *opts[:notify]
+      end
+      if opts[:callback]
+        Groem::Dummy::Server.callback_with *opts[:callback]
+      end
+      EM.run {
+        Signal.trap("INT") { EM.next_tick { EM.stop } }
+        Groem::Dummy::Server.listen
+      }
+      puts '-------------- server process exiting -----------'
+    }    
+  end
+  
+  def self.kill_server(pid)
+    Process.kill("INT", pid)
+  end
+  
+end

data/spec/shared/marshal_helper.rb

@@ -0,0 +1,40 @@
+
+module MarshalHelper
+
+  def self.dummy_request_class
+    Class.new { 
+      include(Groem::Marshal::Request) 
+      require 'forwardable'
+      extend Forwardable
+      def_delegators :@raw, :[], :[]=
+      def raw; @raw ||= {}; end
+      def initialize(input = {})
+        @raw = input
+      end
+    }
+  end
+  
+  def self.dummy_response_class
+    Class.new { 
+      include(Groem::Marshal::Response) 
+      require 'forwardable'
+      extend Forwardable
+      def_delegators :@raw, :[], :[]=
+      def raw; @raw ||= []; end
+      def initialize(input = [])
+        @raw = input
+      end
+    }
+  end
+  
+  def self.dummy_request(env = {}, hdrs = {}, notifs = {})
+    klass = dummy_request_class
+    klass.new({'environment' => env, 
+               'headers' => hdrs,
+               'notifications' => notifs
+              })
+  end
+  
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__))
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default
+
+require 'lib/groem'
+
+Dir[File.expand_path(File.join(File.dirname(__FILE__), 'shared', '**', '*.rb'))].each do |f|
+  load f
+end
+
+Bundler.setup :development
+require 'minitest/spec'
+MiniTest::Unit.autorun

data/spec/unit/app_spec.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe 'Groem::App #[]' do
+
+  describe 'after initializing' do
+    
+    it 'should set the application_name header based on input' do
+      @subject = Groem::App.new('thing')
+      @subject['headers']['Application-Name'].must_equal 'thing'
+    end
+    
+    it 'should default the environment when no options passed' do
+      @subject = Groem::App.new('thing')
+      @subject['environment'].must_equal Groem::App::DEFAULT_ENV
+    end
+    
+    it 'should merge keys from input environment option into default environment' do
+      input = {'version' => '1.2', 
+                'request_method' => 'HELLO',
+                'encryption_id' => 'ABC'
+               }
+      @subject = Groem::App.new('thing', {:environment => input})
+      @subject['environment'].must_equal Groem::App::DEFAULT_ENV.merge(input)
+    end
+    
+    it 'should set each option in headers hash besides environment, host, and port' do
+      opts = {:environment => {}, 
+               :host => 'foo', 
+               :port => 12345,
+               :x_option_1 => '1', 
+               :x_option_2 => '2', 
+               :x_option_3 => '3'
+              }
+      @subject = Groem::App.new('thing', opts)
+      @subject['headers'].must_equal(
+        {'Application-Name' => 'thing',
+         'X-Option-1' => '1',
+         'X-Option-2' => '2',
+         'X-Option-3' => '3'
+        }
+      )
+    end
+
+    it 'should initialize the notifications hash to empty' do
+      @subject = Groem::App.new('thing')
+      @subject['notifications'].must_equal({})
+    end
+    
+  end
+  
+  describe 'after setting header' do
+  
+    it 'should add the header to the headers hash based on input' do
+      @subject = Groem::App.new('thing')
+      @subject.header('x_header', 'boo')
+      @subject['headers']['X-Header'].must_equal 'boo'
+    end
+  
+  end
+  
+  
+  describe 'after setting notification' do
+  
+    it 'should set the notifications hash defaulting enabled to true' do
+      @subject = Groem::App.new('thing')
+      @subject.notification 'action' do end
+      @subject['notifications'].keys.must_include 'action'
+      @subject['notifications']['action'].keys.must_include 'Notification-Enabled'
+      @subject['notifications']['action']['Notification-Enabled'].must_equal 'True'
+    end
+        
+  end
+  
+  
+end
+
+

data/spec/unit/marshal_request_spec.rb

@@ -0,0 +1,380 @@
+require File.join(File.dirname(__FILE__),'..','spec_helper')
+
+describe 'Groem::Marshal::Request.load' do
+
+  #------ REGISTER requests --------#
+  
+  describe 'when valid REGISTER request with one notification and no binaries' do
+    
+    before do
+      @input = <<-__________
+GNTP/1.0 REGISTER NONE
+Application-Name: SurfWriter 
+Application-Icon: http://www.site.org/image.jpg 
+X-Creator:  Apple Software 
+X-Application-ID:08d6c05a21512a79a1dfeb9d2a8f262f 
+ Notifications-Count: 1 
+
+Notification-Name: Download Complete 
+Notification-Display-Name: Download completed 
+Notification-Enabled:True 
+X-Language : English 
+ X-Timezone: PST 
+
+
+__________
+      dummy = Class.new { include(Groem::Marshal::Request) }
+      @subject = dummy.load(@input, false)
+    end
+    
+    it 'should return a hash with keys for environment, headers, and notifications' do
+      @subject.has_key?('environment').must_equal true
+      @subject.has_key?('headers').must_equal true
+      @subject.has_key?('notifications').must_equal true
+    end
+    
+    it 'environment hash should have version == 1.0' do
+      @subject['environment']['version'].must_equal '1.0'
+    end
+
+    it 'environment hash should have request_method == REGISTER' do
+      @subject['environment']['request_method'].must_equal 'REGISTER'
+    end
+    
+    it 'headers hash should have application_name == SurfWriter' do
+      @subject['headers']['Application-Name'].must_equal 'SurfWriter'
+    end
+    
+    it 'headers hash should have notifications_count == 1' do
+      @subject['headers']['Notifications-Count'].must_equal '1'
+    end
+    
+    it 'headers hash should have x_application_id == 08d6c05a21512a79a1dfeb9d2a8f262f' do
+      @subject['headers']['X-Application-ID'].must_equal '08d6c05a21512a79a1dfeb9d2a8f262f'
+    end
+    
+    it 'notifications hash should have 1 key' do
+      @subject['notifications'].keys.size.must_equal 1
+    end
+    
+    it 'notifications hash should have key \'Download Complete\'' do
+      @subject['notifications']['Download Complete'].wont_be_nil
+    end
+    
+    it '\'Download Complete\' notification should have notification_display_name == \'Download completed\'' do
+      @subject['notifications']['Download Complete']['Notification-Display-Name'].must_equal 'Download completed'
+    end
+    
+    it '\'Download Complete\' notification should have notification_enabled == \'True\'' do
+      @subject['notifications']['Download Complete']['Notification-Enabled'].must_equal 'True'
+    end
+    
+    it '\'Download Complete\' notification should have x_timezone == \'PST\'' do
+      @subject['notifications']['Download Complete']['X-Timezone'].must_equal 'PST'
+    end
+    
+    it '\'Download Complete\' notification should have x_language == \'English\'' do
+      @subject['notifications']['Download Complete']['X-Language'].must_equal 'English'
+    end
+    
+    it 'headers hash should not have x_timezone key' do
+      @subject['headers'].has_key?('X-Timezone').must_equal false
+    end
+    
+  end
+    
+  describe 'when valid REGISTER request with three notifications and no binaries' do
+    
+    before do
+      @input = <<-__________
+GNTP/1.0 REGISTER NONE
+Application-Name: SurfWriter 
+Application-Icon: http://www.site.org/image.jpg 
+X-Creator: Apple Software 
+X-Application-ID: 08d6c05a21512a79a1dfeb9d2a8f262f 
+Notifications-Count: 3 
+
+Notification-Name: Download Complete 
+Notification-Display-Name: Download completed 
+Notification-Enabled: True 
+X-Language: English 
+X-Timezone: PST 
+
+Notification-Name: Download Started 
+Notification-Display-Name: Download starting 
+Notification-Enabled: False 
+X-Timezone: GMT 
+
+Notification-Name: Download Error 
+Notification-Display-Name: Error downloading 
+Notification-Enabled: True 
+X-Language: Spanish 
+
+__________
+      dummy = Class.new { include(Groem::Marshal::Request) }
+      @subject = dummy.load(@input, false)
+    end
+    
+    it 'should return a hash with keys for environment, headers, and notifications' do
+      @subject.has_key?('environment').must_equal true
+      @subject.has_key?('headers').must_equal true
+      @subject.has_key?('notifications').must_equal true
+    end
+      
+    it 'notifications hash should have 3 keys' do
+      @subject['notifications'].keys.size.must_equal 3
+    end
+    
+    it 'notifications hash should have key \'Download Complete\'' do
+      @subject['notifications']['Download Complete'].wont_be_nil
+    end
+
+    it 'notifications hash should have key \'Download Started\'' do
+      @subject['notifications']['Download Started'].wont_be_nil
+    end
+    
+    it 'notifications hash should have key \'Download Error\'' do
+      @subject['notifications']['Download Error'].wont_be_nil
+    end
+
+    it '\'Download Complete\' notification should have notification_display_name == \'Download completed\'' do
+      @subject['notifications']['Download Complete']['Notification-Display-Name'].must_equal 'Download completed'
+    end
+
+    it '\'Download Started\' notification should have notification_enabled == \'False\'' do
+      @subject['notifications']['Download Started']['Notification-Enabled'].must_equal 'False'
+    end    
+    
+    it '\'Download Error\' notification should have x_language == \'Spanish\'' do
+      @subject['notifications']['Download Error']['X-Language'].must_equal 'Spanish'
+    end    
+
+    it '\'Download Started\' notification should not have X-Language key' do
+      @subject['notifications']['Download Started'].has_key?('X-Language').must_equal false
+    end    
+    
+    it '\'Download Error\' notification should not have X-Timezone key' do
+      @subject['notifications']['Download Error'].has_key?('X-Timezone').must_equal false
+    end    
+    
+  end
+  
+  describe 'when valid REGISTER request with one binary referenced once in headers' do
+  
+  end
+  
+  describe 'when valid REGISTER request with one binary referenced once in notifications' do
+  
+  end
+
+  describe 'when valid REGISTER request with three binaries referenced once each in headers and notifications' do
+  
+  end
+  
+  describe 'when valid REGISTER request with three binaries referenced twice each in headers and notifications' do
+  
+  end
+  
+  
+  #------ NOTIFY requests --------#
+  
+  describe 'when valid NOTIFY request with no binaries' do
+    
+    before do
+      @input = <<-__________
+GNTP/1.0 NOTIFY NONE
+Application-Name: SurfWriter 
+Notification-Name: Download Complete
+Notification-ID: 999
+Notification-Title:XYZ finished downloading
+ Notification-Sticky: True
+Notification-Icon : http://www.whatever.com/poo.jpg
+
+__________
+      dummy = Class.new { include(Groem::Marshal::Request) }
+      @subject = dummy.load(@input, false)
+    end
+
+    it 'should return a hash with keys for environment, headers, and notifications' do
+      @subject.has_key?('environment').must_equal true
+      @subject.has_key?('headers').must_equal true
+      @subject.has_key?('notifications').must_equal true
+    end
+    
+    it 'environment hash should have version == 1.0' do
+      @subject['environment']['version'].must_equal '1.0'
+    end
+
+    it 'environment hash should have request_method == NOTIFY' do
+      @subject['environment']['request_method'].must_equal 'NOTIFY'
+    end
+    
+    it 'headers hash should have application_name == SurfWriter' do
+      @subject['headers']['Application-Name'].must_equal 'SurfWriter'
+    end
+    
+    it 'headers hash should have notification_title == \'XYZ finished downloading\'' do
+      @subject['headers']['Notification-Title'].must_equal 'XYZ finished downloading'
+    end
+
+    it 'headers hash should have notification_sticky == \'True\'' do
+      @subject['headers']['Notification-Sticky'].must_equal 'True'
+    end
+    
+    it 'headers hash should have notification_icon == \'http://www.whatever.com/poo.jpg\'' do
+      @subject['headers']['Notification-Icon'].must_equal 'http://www.whatever.com/poo.jpg'
+    end
+    
+    it 'notifications hash should be empty' do
+      @subject['notifications'].empty?.must_equal true
+    end
+
+  end
+  
+  describe 'when valid NOTIFY request with one binary referenced once' do
+  
+  end
+
+  describe 'when valid NOTIFY request with three binaries referenced once each' do
+  
+  end
+  
+  describe 'when valid NOTIFY request with three binaries referenced twice each' do
+  
+  end
+  
+end
+
+
+
+#---------- dump -----------#
+  
+
+describe 'Groem::Marshal::Request#dump' do
+  
+  describe 'when valid REGISTER request with one notification, no binaries' do
+    
+    before do
+      @input_env = { 'protocol' => 'GNTP',
+                     'version' => '1.0',
+                     'request_method' => 'REGISTER',
+                     'encryption_id' => 'NONE'
+                    }
+      @input_hdrs = {'Application-Name' => 'SurfWriter',
+                     'Application-Icon' => 'http://www.site.org/image.jpg'
+                    }
+      @input_notifs = { 'Download Complete' => {
+                            'Notification-Display-Name' => 'Download completed',
+                            'Notification-Enabled' => 'True',
+                            'X-Language' => 'English',
+                            'X-Timezone' => 'PST'
+                        }
+                      }
+
+      @subject = MarshalHelper.dummy_request(
+                   @input_env, @input_hdrs, @input_notifs).dump
+    end
+    
+    it 'should output a string' do
+      @subject.class.must_be_same_as String
+      puts
+      puts '------------Groem::Marshal::Request#dump when valid REGISTER request with one notification, no binaries ------------'
+      puts @subject
+    end
+    
+    it 'should output 10 lines terminated by CRLF' do
+      lines = @subject.split("\r\n")
+      lines.size.must_equal 10
+    end
+    
+    it 'should end with 2 CRLF' do
+      @subject[-4,4].must_equal "\r\n\r\n"
+    end
+    
+    it 'should output the first line as the standard GNTP first header' do
+      lines = @subject.split("\r\n")
+      lines[0].must_match(/^#{@input_env['protocol']}\/#{@input_env['version']}\s+#{@input_env['request_method']}\s+#{@input_env['encryption_id']}\s*$/i)
+    end
+    
+    it 'should output the notification count == count of input notifications' do
+      @subject.must_match(/^\s*Notifications-Count\s*:\s*#{@input_notifs.keys.count}\s*$/i)
+    end
+    
+    it 'should have a notification-name line for each input notification' do
+      @input_notifs.each_pair do |name, pairs|
+        @subject.must_match(/^\s*Notification-Name\s*:\s*#{name}\s*$/i)
+      end
+    end
+    
+  end
+  
+  describe 'when valid NOTIFY request with one notification, no binaries' do
+  
+    before do
+      @input_env = { 'protocol' => 'GNTP',
+                     'version' => '1.0',
+                     'request_method' => 'NOTIFY',
+                     'encryption_id' => 'NONE'
+                    }
+      @input_hdrs = {'Application-Name' => 'SurfWriter',
+                     'Notification-Name'=> 'Download Complete',
+                     'Notification-Id' => '999',
+                     'Notification-Title' => 'XYZ finished downloading',
+                     'Notification-Sticky' => 'True',
+                     'Notification-Icon' => 'http://www.whatever.com/poo.jpg'
+                    }
+      @subject = MarshalHelper.dummy_request(
+                   @input_env, @input_hdrs, {}).dump
+    end
+    
+    it 'should output a string' do
+      @subject.class.must_be_same_as String
+      puts
+      puts '------------Groem::Marshal::Request#dump when valid NOTIFY request with one notification, no binaries ------------'
+      puts @subject
+    end
+    
+    it 'should output the first line as the standard GNTP first header for NOTIFY request' do
+      lines = @subject.split("\r\n")
+      lines[0].must_match(/^GNTP\/1.0\s+NOTIFY\s+NONE\s*$/i)
+    end
+    
+    it 'should not output a notification-count line' do
+      @subject.wont_match(/^\s*Notifications-Count\s*:\s*\d+\s*$/i)
+    end
+      
+  end
+  
+  describe 'when no environment' do
+  
+    before do
+      @input_hdrs = {'Application-Name' => 'SurfWriter',
+                     'Notification-Name'=> 'Download Complete',
+                     'Notification-ID' => '999',
+                     'Notification-Title' => 'XYZ finished downloading',
+                     'Notification-Sticky' => 'True',
+                     'Notification-Icon' => 'http://www.whatever.com/poo.jpg'
+                    }
+      @subject = MarshalHelper.dummy_request(
+                   {}, @input_hdrs, {}).dump
+    end
+    
+    it 'should output a string' do
+      @subject.class.must_be_same_as String
+      puts
+      puts '------------Groem::Marshal::Request#dump when no environment ------------'
+      puts @subject
+    end
+    
+    it 'should output the first line as the default GNTP first header for NOTIFY request' do
+      lines = @subject.split("\r\n")
+      lines[0].must_match(/^GNTP\/1.0\s+NOTIFY\s+NONE\s*$/i)
+    end
+    
+    it 'should not output a notification-count line' do
+      @subject.wont_match(/^\s*Notifications-Count\s*:\s*\d+\s*$/i)
+    end
+    
+  end
+    
+end