em-irc 0.0.1 → 0.0.2

data/lib/em-irc/version.rb

@@ -1,5 +1,5 @@
 module EventMachine
   module IRC
-    VERSION = '0.0.1'
+    VERSION = '0.0.2'
   end
 end

data/lib/support/dsl_accessor.rb

@@ -0,0 +1,22 @@
+module DslAccessor
+  def self.included(base)
+    base.extend Macros
+  end
+
+  module Macros
+    def dsl_accessor(*keys)
+      keys.map(&:to_s).each do |k|
+        class_eval <<-ACCESSORS
+          attr_writer :#{k}
+          def #{k}(v = nil)
+            if v
+              @#{k} = v
+            else
+              @#{k}
+            end
+          end
+        ACCESSORS
+      end
+    end
+  end
+end

data/spec/integration/integration_spec.rb

@@ -19,11 +19,16 @@ end
 
 shared_examples_for "integration" do
   it 'should work' do
-    dan = client(nick: 'dan')
-    bob = client(nick: 'bob')
+    dan = client
+    bob = client
+    ace = client
 
-    dan.on(:connect) {dan.join('#americano-test')}
-    bob.on(:connect) {bob.join('#americano-test')}
+    dan.on(:connect) {dan.nick('dan')}
+    bob.on(:connect) {bob.nick('bob')}
+    ace.on(:connect) {ace.nick('bob')}
+
+    dan.on(:nick) {dan.join('#americano-test')}
+    bob.on(:nick) {bob.join('#americano-test')}
 
     bob.on(:join) do |who, channel|
       bob.message(channel, "dan: hello bob")
@@ -31,19 +36,34 @@ shared_examples_for "integration" do
       # dan.quit
     end
 
+    dan.on(:message) do |who, channel, message|
+      @who     = who
+      @channel = channel
+      @message = message
+    end
+
     EM.run {
       dan.connect
-      EM::add_timer(2) {bob.connect}
-      EM::add_timer(5) {EM::stop}
+      bob.connect
+      ace.connect
+      EM::add_timer(2) {EM::stop}
     }
 
     # TODO: matchers for commands
+    dan.nick.should == 'dan'
     dan.history.should =~ /Welcome/
     dan.history.should =~ /JOIN :#americano-test/
-    dan.history.should =~ /dan: hello bob/
 
+    @who.should == "bob"
+    @channel.should == "#americano-test"
+    @message.should == "dan: hello bob"
+
+    bob.nick.should == 'bob'
     bob.history.should =~ /Welcome/
     bob.history.should =~ /JOIN :#americano-test/
+
+    ace.nick.should == nil
+    ace.history.should =~ /Nickname already in use/
   end
 end
 
@@ -51,8 +71,8 @@ end
 describe EventMachine::IRC::Client, :integration => true do
   let(:options) do
     {
-      host: '127.0.0.1',
-      port: '16667'
+      :host => '127.0.0.1',
+      :port => '16667'
     }.merge(@options || {})
   end
 
@@ -71,8 +91,8 @@ describe EventMachine::IRC::Client, :integration => true do
     before :all do
       raise "encrypted ircd not on :16697" unless `lsof -i :16697`.chomp.size > 1
       @options = {
-        port: '16697',
-        ssl: true
+        :port => '16697',
+        :ssl  => true
       }
     end
     it_behaves_like "integration"

data/spec/lib/em-irc/client_spec.rb

@@ -26,16 +26,23 @@ describe EventMachine::IRC::Client do
       subject.should_not be_connected
     end
 
-    it 'should default a nick' do
-      subject.nick.should_not be_blank
+    it 'should have blank nick' do
+      subject.nick.should be_blank
     end
 
-    it 'should yield self' do
-      client = described_class.new do |c|
+    it 'should optionally yield self' do
+      described_class.new do |c|
         c.should be_kind_of(described_class)
       end
     end
 
+    it 'should optionally instance eval' do
+      client = described_class.new do
+        host 'stella.net'
+      end
+      client.host.should == 'stella.net'
+    end
+
     it 'should allow a custom logger' do
       subject.logger = Logger.new(STDOUT)
       subject.logger = nil
@@ -43,15 +50,15 @@ describe EventMachine::IRC::Client do
   end
 
   context 'connect' do
-    it 'should create an EM TCP connection with host, port, handler, and self' do
-      EventMachine.should_receive(:connect).with('irc.net', '9999', EventMachine::IRC::Dispatcher, parent: subject)
+    it 'should create an EM TCP connection with host, port, handler, and ssl' do
+      EventMachine.should_receive(:connect).with('irc.net', '9999', EventMachine::IRC::Dispatcher, :parent => subject, :ssl => subject.ssl)
       subject.host = 'irc.net'
       subject.port = '9999'
       subject.connect
     end
 
     it 'should be idempotent' do
-      EventMachine.stub(connect: mock('Connection'))
+      EventMachine.stub(:connect => mock('Connection'))
       EventMachine.should_receive(:connect).exactly(1).times
       subject.connect
       subject.connect
@@ -61,17 +68,17 @@ describe EventMachine::IRC::Client do
   context 'send_data' do
     before do
       @connection = mock('Connection')
-      subject.stub(conn: @connection)
-      subject.stub(connected?: true)
+      subject.stub(:conn => @connection)
+      subject.stub(:connected? => true)
     end
 
     it 'should return false if not connected' do
-      subject.stub(connected?: nil)
+      subject.stub(:connected? => nil)
       subject.send_data("NICK jch").should be_false
     end
 
     it 'should send message to irc server' do
-      subject.stub(conn: @connection)
+      subject.stub(:conn => @connection)
       @connection.should_receive(:send_data).with("NICK jch\r\n")
       subject.send_data("NICK jch")
     end
@@ -79,7 +86,7 @@ describe EventMachine::IRC::Client do
 
   context 'ready' do
     before do
-      subject.stub(conn: mock.as_null_object)
+      subject.stub(:conn => mock.as_null_object)
     end
 
     it 'should call :connect callback' do
@@ -122,48 +129,49 @@ describe EventMachine::IRC::Client do
         parsed = subject.parse_message('PING :irc.net')
         parsed[:params] =~ ['irc.net']
       end
+
+      it 'should return strings as a single param' do
+        parsed = subject.parse_message(":irc.the.net 001 jessie :Welcome to the Internet Relay Network jessie!~jessie@localhost")
+        parsed[:params] =~ ['jessie', 'Welcome to the Internet Relay Network jessie!~jessie@localhost']
+      end
     end
   end
 
   context 'receive_data' do
-    before do
-      subject.stub(:parse_message).and_return(mock.as_null_object)
-      subject.stub(:handle_parsed_message).and_return(mock.as_null_object)
-    end
-
-    it 'should parse messages separated by \r\n' do
-      data = [
+    let(:data) {
+      [
         ":irc.the.net 001 jessie :Welcome to the Internet Relay Network jessie!~jessie@localhost",
         ":irc.the.net 002 jessie :Your host is irc.the.net, running version ngircd-17.1 (i386/apple/darwin11.2.0)",
         ":irc.the.net 003 jessie :This server has been started Fri Feb 03 2012 at 14:42:38 (PST)"
       ].join("\r\n")
+    }
+    let(:parsed_message) {mock.as_null_object}
+
+    before do
+      subject.stub(:parse_message).and_return(parsed_message)
+      subject.stub(:handle_parsed_message)
+    end
 
+    it 'should parse messages separated by \r\n' do
       subject.should_receive(:parse_message).exactly(3).times
-      subject.should_receive(:handle_parsed_message).exactly(3).times
       subject.receive_data(data)
     end
 
     it 'should handle parsed messages' do
+      subject.should_receive(:handle_parsed_message).exactly(3).times
+      subject.receive_data(data)
     end
-  end
 
-  context 'handle_parsed_message' do
-    it 'should respond to pings' do
-      subject.should_receive(:pong).with("irc.net")
-      subject.handle_parsed_message({prefix: 'irc.net', command: 'PING', params: ['irc.net']})
+    it 'should trigger :raw callbacks' do
+      subject.should_receive(:trigger).with(:raw, parsed_message).exactly(3).times
+      subject.receive_data(data)
     end
+  end
 
-    # TODO: do we want a delegate object and callbacks?
-    # it 'should call optional delegate' do
-    #   subject.stub(delegate: mock('Delegate'))
-    #   subject.delegate.should_receive(:message)
-    #   subject.handle_parsed_message({prefix: 'jessie!jessie@localhost', command: 'PRIVMSG', params: ['#general', 'hello world'])
-    # end
-
-    it 'should trigger :raw callbacks' do
-      m = mock('Parsed Response').as_null_object
-      subject.should_receive(:trigger).with(:raw, m)
-      subject.handle_parsed_message(m)
+  context 'handle_parsed_message' do
+    it 'should trigger error for messages 400-599' do
+      subject.should_receive(:trigger).with(:error, 'ERR_NICKNAMEINUSE')
+      subject.handle_parsed_message(:command => '433', :params => ['ERR_NICKNAMEINUSE'])
     end
   end
 

data/spec/lib/em-irc/commands_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+describe EventMachine::IRC::Commands do
+  subject {EventMachine::IRC::Client.new}
+
+  context "nick" do
+    it 'should set nick' do
+      subject.should_receive(:send_data).with("NICK jch")
+      subject.nick('jch')
+    end
+
+    it 'should get nick' do
+      subject.instance_eval {@nick = 'jch'}
+      subject.nick.should == 'jch'
+    end
+  end
+
+  context "join" do
+    it 'should join single channel' do
+      subject.should_receive(:send_data).with("JOIN #general")
+      subject.join("#general")
+    end
+
+    it 'should join multiple channels' do
+      subject.should_receive(:send_data).with("JOIN #general,#foo")
+      subject.join('#general', '#foo')
+    end
+
+    it 'should join channels with keys' do
+      subject.should_receive(:send_data).with("JOIN #foo,&bar fubar,bazly")
+      subject.join(['#foo', 'fubar'], ['&bar', 'bazly'])
+    end
+
+    it 'should join channels with and without keys' do
+      subject.should_receive(:send_data).with("JOIN #foo,#cat,&bar fubar,dog")
+      subject.join(['#foo', 'fubar'], '&bar', ["#cat", "dog"])
+    end
+
+    it 'should leave all currently joined channels' do
+      subject.should_receive(:join).with('0')
+      subject.join('0')
+    end
+  end
+
+  context "part_all" do
+    it 'should leave all currently joined channels' do
+      subject.should_receive(:join).with('0')
+      subject.part_all
+    end
+  end
+
+  context "part" do
+    it 'should part single' do
+      subject.should_receive(:send_data).with('PART #general :Leaving...')
+      subject.part('#general')
+    end
+
+    it 'should part single with custom message' do
+      subject.should_receive(:send_data).with('PART #general :Goodbye everybody!')
+      subject.part('#general', 'Goodbye everybody!')
+    end
+
+    it 'should part multiple' do
+      subject.should_receive(:send_data).with('PART #general,#foo :Leaving...')
+      subject.part('#general', '#foo')
+    end
+
+    it 'should part multiple with custom message' do
+      subject.should_receive(:send_data).with('PART #general,#foo :Goodbye everybody!')
+      subject.part('#general', '#foo', 'Goodbye everybody!')
+    end
+  end
+
+  context "topic" do
+    it 'should get topic' do
+      subject.should_receive(:send_data).with("TOPIC #foo")
+      subject.topic('#foo')
+    end
+
+    it 'should set topic' do
+      subject.should_receive(:send_data).with("TOPIC #foo :awesome channel")
+      subject.topic('#foo', "awesome channel")
+    end
+
+    it 'should unset topic' do
+      subject.should_receive(:send_data).with("TOPIC #foo :")
+      subject.topic('#foo', '')
+    end
+  end
+
+  context "names" do
+    it 'should list names for a single channel' do
+      subject.should_receive(:send_data).with("NAMES #foo")
+      subject.names("#foo")
+    end
+
+    it 'should list names for multiple channels' do
+      subject.should_receive(:send_data).with("NAMES #foo,&bar")
+      subject.names("#foo", "&bar")
+    end
+
+    it 'should list names with a target server' do
+      subject.should_receive(:send_data).with("NAMES #foo,&bar irc.net")
+      subject.names("#foo", "&bar", :target => 'irc.net')
+    end
+  end
+
+  context "list" do
+    it 'should list channel and topic' do
+      subject.should_receive(:send_data).with("LIST #foo")
+      subject.list("#foo")
+    end
+
+    it 'should list channels and topics for multiple channels' do
+      subject.should_receive(:send_data).with("LIST #foo,&bar")
+      subject.list("#foo", "&bar")
+    end
+
+    it 'should list names with a target server' do
+      subject.should_receive(:send_data).with("LIST #foo,&bar irc.net")
+      subject.list("#foo", "&bar", :target => 'irc.net')
+    end
+  end
+
+  context 'invite' do
+    it 'should invite user to a channel' do
+      subject.should_receive(:send_data).with("INVITE jch #foo")
+      subject.invite("jch", "#foo")
+    end
+  end
+
+  context 'kick' do
+    it 'should kick user from channel' do
+      subject.should_receive(:send_data).with("KICK #general jch")
+      subject.kick("#general", "jch")
+    end
+
+    it 'should kick multiple users from channels' do
+      subject.should_receive(:send_data).with("KICK #general,&bar jch,wcc")
+      subject.kick("#general", "&bar", "jch", "wcc")
+    end
+
+    it 'should raise error if no channels' do
+      expect {
+        subject.kick('jch')
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'whois' do
+    it 'should query user' do
+      subject.should_receive(:send_data).with("WHOIS jch")
+      subject.whois('jch')
+    end
+
+    it 'should query users' do
+      subject.should_receive(:send_data).with("WHOIS jch,bar")
+      subject.whois('jch', 'bar')
+    end
+
+    it 'should query user from a target server' do
+      subject.should_receive(:send_data).with("WHOIS irc.net jch,bar")
+      subject.whois('jch', 'bar', :target => 'irc.net')
+    end
+  end
+end

data/spec/lib/em-irc/dispatcher_spec.rb

@@ -2,12 +2,14 @@ require 'spec_helper'
 
 shared_examples_for 'dispatcher' do
   it 'should delegate connection methods to parent' do
-    parent = Class.new do
-      attr_accessor :conn
-      def ssl
-        $ssl
+    module TestServer
+      def post_init
+        send_data "message"
       end
+    end
 
+    parent = Class.new do
+      attr_accessor :conn
       def receive_data(data)
         EventMachine::stop_event_loop
         raise "Didn't get expected message" unless data == 'message'
@@ -16,11 +18,9 @@ shared_examples_for 'dispatcher' do
     parent.should_receive(:ready)
     parent.should_receive(:unbind)
     EventMachine.run {
-      EventMachine::start_server('127.0.0.1', '198511', described_class, parent: parent)
-      EventMachine::connect('127.0.0.1', '198511') do |conn|
-        conn.send_data("message")
-      end
-      EventMachine::add_timer(2) {
+      EventMachine::start_server('127.0.0.1', '198511', TestServer)
+      EventMachine::connect('127.0.0.1', '198511', EventMachine::IRC::Dispatcher, :parent => parent, :ssl => ssl)
+      EventMachine::add_timer(3) {
         EventMachine::stop_event_loop
         raise "Never reached receive_data or took too long"
       }
@@ -30,15 +30,15 @@ end
 
 describe EventMachine::IRC::Dispatcher do
   context 'ssl integration' do
-    before {$ssl = true}
-    it 'behaves like dispatcher' do
-      pending "not sure how to test ssl"
-    end
-    # it_behaves_like "dispatcher"
+    it "how to test ssl?"
+    # it_behaves_like "dispatcher" do
+    #   let(:ssl) {true}
+    # end
   end
 
   context 'non-ssl integration' do
-    before {$ssl = false}
-    it_behaves_like "dispatcher"
+    it_behaves_like "dispatcher" do
+      let(:ssl) {false}
+    end
   end
 end