akane 0.0.1

data/lib/akane/storages/mock.rb

@@ -0,0 +1,51 @@
+require 'akane/storages/abstract_storage'
+
+module Akane
+  module Storages
+    class Mock < AbstractStorage
+      class << self
+        def recorded_tweets
+          @recorded_tweets ||= []
+        end
+
+        def deletion_marks
+          @deletion_marks ||= []
+        end
+
+        def recorded_events
+          @recorded_events ||= []
+        end
+
+        def recorded_messages
+          @recorded_messages ||= []
+        end
+
+        def reset!
+          [recorded_tweets, deletion_marks,
+            recorded_events, recorded_messages].each(&:clear)
+          self
+        end
+      end
+
+      def record_tweet(account, tweet)
+        self.class.recorded_tweets << [account, tweet]
+        self
+      end
+
+      def mark_as_deleted(account, user_id, tweet_id)
+        self.class.deletion_marks << [account, user_id, tweet_id]
+        self
+      end
+
+      def record_event(account, event)
+        self.class.recorded_events << [account, event]
+        self
+      end
+
+      def record_message(account, message)
+        self.class.recorded_messages << [account, message]
+        self
+      end
+    end
+  end
+end

data/lib/akane/storages/stdout.rb

@@ -0,0 +1,23 @@
+require 'akane/storages/abstract_storage'
+
+module Akane
+  module Storages
+    class Stdout < AbstractStorage
+      def record_tweet(account, tweet)
+        $stdout.puts "[#{account}] #{tweet["user"]["screen_name"]}: #{tweet["text"]}"
+      end
+
+      def mark_as_deleted(account, user_id, tweet_id)
+        $stdout.puts "[#{account}](DELETION) #{user_id}/#{tweet_id}"
+      end
+
+      def record_event(account, event)
+        $stdout.puts "[#{account}](EVENT) #{event["event"]}: #{event["source"]["screen_name"]}-> #{event["target"]["screen_name"]}"
+      end
+
+      def record_message(account, message)
+        $stdout.puts "[#{account}](DM) #{message["user"]["screen_name"]}: #{message["text"]}"
+      end
+    end
+  end
+end

data/lib/akane/version.rb

@@ -0,0 +1,3 @@
+module Akane
+  VERSION = "0.0.1"
+end

data/spec/config_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'logger'
+require 'akane/config'
+
+describe Akane::Config do
+  subject { described_class.new("log" => File::NULL, "foo" => "bar") }
+
+  describe "#logger" do
+    it "returns logger" do
+      expect(subject.logger).to be_a_kind_of(Logger)
+    end
+  end
+
+  describe "#[]" do
+    it "returns from config hash" do
+      expect(subject["foo"]).to eq "bar"
+    end
+  end
+end

data/spec/manager_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+require 'eventmachine'
+require 'akane/manager'
+require 'akane/receivers/stream'
+require 'akane/storages/mock'
+require 'akane/config'
+
+describe Akane::Manager do
+  let(:conf_accounts) do
+    {
+      "a" => {"token" => "a-access-token", "secret" => "a-access-secret"},
+    }
+  end
+  let(:conf_storages) do
+    [
+      { "mock" => {"a" => "b"} }
+    ]
+  end
+
+  let(:config) do
+    Akane::Config.new(
+      "consumer" => {
+        "token" => "consumer-token", "secret" => "consumer-secret"
+      },
+      "accounts" => conf_accounts,
+      "storages" => conf_storages
+    ).tap { |_| _.stub(logger: Logger.new(nil)) }
+  end
+
+  subject { Akane::Manager.new(config) }
+
+  before do
+    EM.stub(:run) { |&block| block.call }
+  end
+
+  # receivers -> manager -> recorder -> storage
+
+  describe "#prepare" do
+    it "creates receivers" do
+      Akane::Receivers::Stream.should_receive(:new) \
+        .with(consumer: {token: 'consumer-token', secret: 'consumer-secret'},
+              account:  {token: 'a-access-token', secret: 'a-access-secret'},
+              logger: config.logger) \
+        .and_return(double("a").as_null_object)
+
+      subject.prepare
+    end
+
+    it "instantiates storages" do
+      Akane::Storages::Mock.should_receive(:new).with(config: {"a" => "b"}, logger: config.logger)
+      subject.prepare
+    end
+
+    it "creates recorder with storages" do
+      storage = double("storage")
+      Akane::Storages::Mock.stub(new: storage)
+      Akane::Recorder.should_receive(:new).with([storage], logger: config.logger).and_call_original
+
+      subject.prepare
+    end
+  end
+
+  describe "#start" do
+    let(:receiver) { double("a").as_null_object }
+    let(:recorder) { double("recorder").as_null_object }
+    before do
+      Akane::Receivers::Stream.stub(new: receiver)
+      Akane::Recorder.stub(new: recorder)
+
+      @on_event, @on_tweet, @on_delete, @on_message = nil
+      receiver.stub(:on_event)   { |&block| @on_event   = block }
+      receiver.stub(:on_tweet)   { |&block| @on_tweet   = block }
+      receiver.stub(:on_delete)  { |&block| @on_delete  = block }
+      receiver.stub(:on_message) { |&block| @on_message = block }
+
+      subject.prepare
+    end
+
+    it "starts all receivers" do
+      receiver.should_receive(:start)
+      subject.start
+    end
+
+    it "starts all receivers" do
+      recorder.should_receive(:run)
+      subject.start
+    end
+
+    it "sends all to recorder" do
+      subject.start
+
+      recorder.should_receive(:record_tweet).with('a', "id" => 42)
+      recorder.should_receive(:record_event).with('a', "event" => 'favorite')
+      recorder.should_receive(:mark_as_deleted).with('a', 5, 420)
+      recorder.should_receive(:record_message).with('a', 'mes' => 'sage')
+
+      @on_tweet.call("id" => 42)
+      @on_event.call("event" => 'favorite')
+      @on_delete.call(5, 420)
+      @on_message.call('mes' => 'sage')
+    end
+  end
+
+  describe "#run" do
+    it "calls setup then start"
+  end
+end

data/spec/receivers/abstract_receiver_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'akane/receivers/abstract_receiver'
+
+describe Akane::Receivers::AbstractReceiver do
+=begin
+  subject { described_class.new(consumer: {token: 'consumer-token', secret: 'consumer-secret'}, account: {token: '42-access-token', secret: 'access-secret'}) }
+  describe "#start" do
+    it "starts listening" do
+      subject.start
+    end
+
+    it "starts returning running? true" do
+      expect { subject.start } \
+        .to change { subject.running? } \
+        .from(false).to(true)
+    end
+  end
+
+  describe "#stop" do
+    it "stops listening" do
+      subject.stop
+    end
+
+    it "stops returning running? true" do
+      subject.start
+
+      expect { subject.stop } \
+        .to change { subject.running? } \
+        .from(true).to(false)
+    end
+  end
+
+  describe "when received tweet" do
+    it "calls on_tweet hook" do
+    end
+  end
+
+  describe "when received event" do
+    it "calls on_event hook" do
+    end
+  end
+
+  describe "when error occured" do
+    it "calls on_error hook" do
+    end
+  end
+=end
+end

data/spec/receivers/stream_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'logger'
+require 'akane/receivers/stream'
+
+describe Akane::Receivers::Stream do
+  let(:config) { {} }
+  subject { described_class.new(consumer: {token: 'consumer-token', secret: 'consumer-secret'}, account: {token: '42-access-token', secret: 'access-secret'}, config: config, logger: Logger.new(nil)) }
+
+  after(:each) do
+    TweetStream::MockClient.clients.clear
+  end
+
+  describe "#start" do
+    it "starts listening" do
+      expect { subject.start } \
+        .to change { TweetStream::MockClient.clients.size } \
+        .by(1)
+    end
+
+    it "starts returning running? true" do
+      expect { subject.start } \
+        .to change { subject.running? } \
+        .from(false).to(true)
+    end
+  end
+
+  describe "#stop" do
+    before do
+      subject.start
+    end
+
+    it "stops listening" do
+      expect { subject.stop } \
+        .to change { TweetStream::MockClient.clients.size } \
+        .by(-1)
+    end
+
+    it "stops returning running? true" do
+      expect { subject.stop } \
+        .to change { subject.running? } \
+        .from(true).to(false)
+    end
+  end
+
+  describe "when received tweet" do
+    before do
+      subject.start
+    end
+
+    it "calls on_tweet hook" do
+      called = nil
+      subject.on_tweet do |tweet|
+        called = tweet
+      end
+      TweetStream::MockClient.invoke('timeline_status', foo: :bar)
+      expect(called).to eq(foo: :bar)
+    end
+  end
+
+  describe "when received message" do
+    before do
+      subject.start
+    end
+
+    it "calls on_message hook" do
+      called = nil
+      subject.on_message do |message|
+        called = message
+      end
+      TweetStream::MockClient.invoke('direct_message', foo: :bar)
+      expect(called).to eq(foo: :bar)
+    end
+  end
+
+  describe "when received deletion" do
+    before do
+      subject.start
+    end
+
+    it "calls on_delete hook" do
+      called = nil
+      subject.on_delete do |u,t|
+        called = [u,t]
+      end
+      TweetStream::MockClient.invoke('delete', 424242, 42)
+      expect(called).to eq([42,424242])
+    end
+  end
+
+  describe "when received event" do
+    before do
+      subject.start
+    end
+
+    it "calls on_event hook" do
+      called = nil
+      subject.on_event do |h|
+        called = h
+      end
+      TweetStream::MockClient.invoke('anything', "event" => "favorite")
+      TweetStream::MockClient.invoke('anything', "something" => "else")
+      expect(called).to eq("event" => "favorite")
+    end
+  end
+end

data/spec/recorder_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'akane/recorder'
+
+describe Akane::Recorder do
+  let(:storages) do
+    [
+      double("storage0")
+    ]
+  end
+  subject { described_class.new(storages) }
+
+  describe "recording tweets" do
+    it "records tweet" do
+      storages[0].should_receive(:record_tweet).with('a', {"id" => 42})
+      subject.record_tweet('a', "id" => 42)
+      subject.dequeue(true)
+    end
+
+    it "doesn't record tweets which already recorded recently" do
+      storages[0].should_receive(:record_tweet).with('a', {"id" => 40})
+      storages[0].should_receive(:record_tweet).with('a', {"id" => 42})
+
+      subject.record_tweet('a', "id" => 40)
+      subject.record_tweet('a', "id" => 42)
+      subject.dequeue(true)
+      subject.dequeue(true)
+      subject.record_tweet('a', "id" => 42)
+      subject.dequeue(true)
+    end
+
+    it "records retweeted tweet" do
+      tweet = {"id" => 42, "text" => "foo", "user" => {"id" => 1, "screen_name" => "a"}}
+      retweet = {"id" => 43, "text" => "RT @a: foo", "user" => {"id" => 2, "screen_name" => "b"}, "retweeted_status" => tweet}
+      storages[0].should_receive(:record_tweet).with('a', retweet)
+      storages[0].should_receive(:record_tweet).with('a', tweet)
+      subject.record_tweet('a', retweet)
+      subject.dequeue(true)
+    end
+  end
+
+  describe "marking deletion" do
+    it "marks as deleted" do
+      subject.mark_as_deleted('foo', 1, 42)
+
+      storages[0].should_receive(:mark_as_deleted).with('foo', 1, 42)
+      subject.dequeue(true)
+    end
+  end
+
+  describe "recording messages" do
+    it "records message" do
+      subject.record_message('foo', {"id" => 42})
+
+      storages[0].should_receive(:record_message).with('foo', "id" => 42)
+      subject.dequeue(true)
+    end
+  end
+
+  describe "recording event" do
+    it "records event" do
+      subject.record_event('foo', {"event" => "favorite"})
+
+      storages[0].should_receive(:record_event).with('foo', "event" => "favorite")
+      subject.dequeue(true)
+    end
+  end
+
+  describe "#run" do
+    before do
+      @th = Thread.new { subject.run(true) }
+      @th.abort_on_exception = true
+    end
+
+    it "continues dequeuing the queue" do
+      storages[0].should_receive(:record_tweet).with('a', {"id" => 42})
+      storages[0].should_receive(:record_tweet).with('b', {"id" => 43})
+      subject.record_tweet('a', "id" => 42)
+      subject.record_tweet('b', "id" => 43)
+      10.times { break if subject.queue_length.zero?; sleep 0.1 }
+    end
+
+    after do
+      @th.kill if @th && @th.alive?
+    end
+  end
+end